74 files changed, 1433 insertions, 846 deletions
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)
+        item.kind(CompletionItemKind::Keyword);
-            .add_to(acc);
+        item.add_to(acc);
        if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
            .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
        {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
+            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "super::");
-                .kind(CompletionItemKind::Keyword)
+            item.kind(CompletionItemKind::Keyword).insert_text("super::");
-                .insert_text("super::")
+            item.add_to(acc);
-                .add_to(acc);
        }
    }
@@ -34,11 +32,10 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    if let Some(receiver) = &ctx.dot_receiver {
        if let Some(ty) = ctx.sema.type_of_expr(receiver) {
            if ty.impls_future(ctx.db) {
-                CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+                let mut item =
-                    .kind(CompletionItemKind::Keyword)
+                    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await");
-                    .detail("expr.await")
+                item.kind(CompletionItemKind::Keyword).detail("expr.await").insert_text("await");
-                    .insert_text("await")
+                item.add_to(acc);
-                    .add_to(acc);
            }
        };
    }
@@ -165,9 +162,10 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
 }
 fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
-    let builder = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+    let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw);
-        .kind(CompletionItemKind::Keyword);
+    item.kind(CompletionItemKind::Keyword);
-    let builder = match ctx.config.snippet_cap {
+    match ctx.config.snippet_cap {
        Some(cap) => {
            let tmp;
            let snippet = if snippet.ends_with('}') && ctx.incomplete_let {
@@ -177,11 +175,13 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
            } else {
                snippet
            };
-            builder.insert_snippet(cap, snippet)
+            item.insert_snippet(cap, snippet);
+        }
+        None => {
+            item.insert_text(if snippet.contains('$') { kw } else { snippet });
        }
-        None => builder.insert_text(if snippet.contains('$') { kw } else { snippet }),
    };
-    acc.add(builder.build());
+    item.add_to(acc);
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/mod_.rs b/crates/ide_completion/src/completions/mod_.rs
index 352fc7c77..4f9415736 100644
--- a/crates/ide_completion/src/completions/mod_.rs
+++ b/crates/ide_completion/src/completions/mod_.rs
@@ -80,9 +80,9 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
            if mod_under_caret.semicolon_token().is_none() {
                label.push(';');
            }
-            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
+            let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label);
-                .kind(SymbolKind::Module)
+            item.kind(SymbolKind::Module);
-                .add_to(acc)
+            item.add_to(acc)
        });
    Some(())
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index d45ad7944..ac69b720a 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -297,10 +297,9 @@ fn postfix_snippet(
        let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
        TextEdit::replace(delete_range, snippet.to_string())
    };
-    CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
-        .detail(detail)
+    item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
-        .kind(CompletionItemKind::Snippet)
+    item
-        .snippet_edit(cap, edit)
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index 0a7927eb8..2f95b8687 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -22,16 +22,13 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
                let completion_text = completion_text
                    .strip_prefix(ctx.token.to_string().as_str())
                    .unwrap_or(completion_text);
-                acc.add(
+                let mut item = CompletionItem::new(
-                    CompletionItem::new(
+                    CompletionKind::Snippet,
-                        CompletionKind::Snippet,
+                    ctx.source_range(),
-                        ctx.source_range(),
+                    "..Default::default()",
-                        "..Default::default()",
-                    )
-                    .insert_text(completion_text)
-                    .kind(SymbolKind::Field)
-                    .build(),
                );
+                item.insert_text(completion_text).kind(SymbolKind::Field);
+                item.add_to(acc);
            }
            missing_fields
diff --git a/crates/ide_completion/src/completions/snippet.rs b/crates/ide_completion/src/completions/snippet.rs
index df17a15c5..7f7830976 100644
--- a/crates/ide_completion/src/completions/snippet.rs
+++ b/crates/ide_completion/src/completions/snippet.rs
@@ -8,9 +8,9 @@ use crate::{
 };
 fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
-    CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label);
-        .insert_snippet(cap, snippet)
+    item.insert_snippet(cap, snippet).kind(CompletionItemKind::Snippet);
-        .kind(CompletionItemKind::Snippet)
+    item
 }
 pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
@@ -35,7 +35,7 @@ pub(crate) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionConte
        None => return,
    };
-    snippet(
+    let mut item = snippet(
        ctx,
        cap,
        "tmod (Test module)",
@@ -49,11 +49,11 @@ mod tests {
        $0
    }
 }",
-    )
+    );
-    .lookup_by("tmod")
+    item.lookup_by("tmod");
-    .add_to(acc);
+    item.add_to(acc);
-    snippet(
+    let mut item = snippet(
        ctx,
        cap,
        "tfn (Test function)",
@@ -62,11 +62,12 @@ mod tests {
 fn ${1:feature}() {
    $0
 }",
-    )
+    );
-    .lookup_by("tfn")
+    item.lookup_by("tfn");
-    .add_to(acc);
+    item.add_to(acc);
-    snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
+    let item = snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}");
+    item.add_to(acc);
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index b999540b8..5a7361f8e 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -145,9 +145,8 @@ fn add_function_impl(
        format!("fn {}(..)", fn_name)
    };
-    let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
-        .lookup_by(fn_name)
+    item.lookup_by(fn_name).set_documentation(func.docs(ctx.db));
-        .set_documentation(func.docs(ctx.db));
    let completion_kind = if func.self_param(ctx.db).is_some() {
        CompletionItemKind::Method
@@ -161,15 +160,15 @@ fn add_function_impl(
        match ctx.config.snippet_cap {
            Some(cap) => {
                let snippet = format!("{} {{\n    $0\n}}", function_decl);
-                builder.snippet_edit(cap, TextEdit::replace(range, snippet))
+                item.snippet_edit(cap, TextEdit::replace(range, snippet));
            }
            None => {
                let header = format!("{} {{", function_decl);
-                builder.text_edit(TextEdit::replace(range, header))
+                item.text_edit(TextEdit::replace(range, header));
            }
-        }
+        };
-        .kind(completion_kind)
+        item.kind(completion_kind);
-        .add_to(acc);
+        item.add_to(acc);
    }
 }
@@ -185,12 +184,12 @@ fn add_type_alias_impl(
    let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
-    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+    let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
-        .text_edit(TextEdit::replace(range, snippet))
+    item.text_edit(TextEdit::replace(range, snippet))
        .lookup_by(alias_name)
        .kind(SymbolKind::TypeAlias)
-        .set_documentation(type_alias.docs(ctx.db))
+        .set_documentation(type_alias.docs(ctx.db));
-        .add_to(acc);
+    item.add_to(acc);
 }
 fn add_const_impl(
@@ -208,12 +207,13 @@ fn add_const_impl(
            let range =
                TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
-            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+            let mut item =
-                .text_edit(TextEdit::replace(range, snippet))
+                CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
+            item.text_edit(TextEdit::replace(range, snippet))
                .lookup_by(const_name)
                .kind(SymbolKind::Const)
-                .set_documentation(const_.docs(ctx.db))
+                .set_documentation(const_.docs(ctx.db));
-                .add_to(acc);
+            item.add_to(acc);
        }
    }
 }
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 9b039e3e5..3febab32b 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -63,12 +63,18 @@ pub struct CompletionItem {
    /// after completion.
    trigger_call_info: bool,
-    /// Score is useful to pre select or display in better order completion items
+    /// We use this to sort completion. Relevance records facts like "do the
-    score: Option<CompletionScore>,
+    /// types align precisely?". We can't sort by relevances directly, they are
+    /// only partially ordered.
+    ///
+    /// Note that Relevance ignores fuzzy match score. We compute Relevance for
+    /// all possible items, and then separately build an ordered completion list
+    /// based on relevance and fuzzy matching with the already typed identifier.
+    relevance: CompletionRelevance,
    /// Indicates that a reference or mutable reference to this variable is a
    /// possible match.
-    ref_match: Option<(Mutability, CompletionScore)>,
+    ref_match: Option<Mutability>,
    /// The import data to add to completion's edits.
    import_to_add: Option<ImportEdit>,
@@ -101,8 +107,13 @@ impl fmt::Debug for CompletionItem {
        if self.deprecated {
            s.field("deprecated", &true);
        }
-        if let Some(score) = &self.score {
-            s.field("score", score);
+        if self.relevance != CompletionRelevance::default() {
+            s.field("relevance", &self.relevance);
+        }
+        if let Some(mutability) = &self.ref_match {
+            s.field("ref_match", &format!("&{}", mutability.as_keyword_for_ref()));
        }
        if self.trigger_call_info {
            s.field("trigger_call_info", &true);
@@ -111,12 +122,59 @@ impl fmt::Debug for CompletionItem {
    }
 }
-#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
-pub enum CompletionScore {
+pub struct CompletionRelevance {
-    /// If only type match
+    /// This is set in cases like these:
-    TypeMatch,
+    ///
-    /// If type and name match
+    /// ```
-    TypeAndNameMatch,
+    /// fn f(spam: String) {}
+    /// fn main {
+    ///     let spam = 92;
+    ///     f($0) // name of local matches the name of param
+    /// }
+    /// ```
+    pub exact_name_match: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn f(spam: String) {}
+    /// fn main {
+    ///     let foo = String::new();
+    ///     f($0) // type of local matches the type of param
+    /// }
+    /// ```
+    pub exact_type_match: bool,
+}
+impl CompletionRelevance {
+    /// Provides a relevance score. Higher values are more relevant.
+    ///
+    /// The absolute value of the relevance score is not meaningful, for
+    /// example a value of 0 doesn't mean "not relevant", rather
+    /// it means "least relevant". The score value should only be used
+    /// for relative ordering.
+    ///
+    /// See is_relevant if you need to make some judgement about score
+    /// in an absolute sense.
+    pub fn score(&self) -> u32 {
+        let mut score = 0;
+        if self.exact_name_match {
+            score += 1;
+        }
+        if self.exact_type_match {
+            score += 1;
+        }
+        score
+    }
+    /// Returns true when the score for this threshold is above
+    /// some threshold such that we think it is especially likely
+    /// to be relevant.
+    pub fn is_relevant(&self) -> bool {
+        self.score() > 0
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -208,9 +266,9 @@ impl CompletionItem {
            lookup: None,
            kind: None,
            text_edit: None,
-            deprecated: None,
+            deprecated: false,
            trigger_call_info: None,
-            score: None,
+            relevance: CompletionRelevance::default(),
            ref_match: None,
            import_to_add: None,
        }
@@ -253,16 +311,22 @@ impl CompletionItem {
        self.deprecated
    }
-    pub fn score(&self) -> Option<CompletionScore> {
+    pub fn relevance(&self) -> CompletionRelevance {
-        self.score
+        self.relevance
    }
    pub fn trigger_call_info(&self) -> bool {
        self.trigger_call_info
    }
-    pub fn ref_match(&self) -> Option<(Mutability, CompletionScore)> {
+    pub fn ref_match(&self) -> Option<(Mutability, CompletionRelevance)> {
-        self.ref_match
+        // Relevance of the ref match should be the same as the original
+        // match, but with exact type match set because self.ref_match
+        // is only set if there is an exact type match.
+        let mut relevance = self.relevance;
+        relevance.exact_type_match = true;
+        self.ref_match.map(|mutability| (mutability, relevance))
    }
    pub fn import_to_add(&self) -> Option<&ImportEdit> {
@@ -308,10 +372,10 @@ pub(crate) struct Builder {
    lookup: Option<String>,
    kind: Option<CompletionItemKind>,
    text_edit: Option<TextEdit>,
-    deprecated: Option<bool>,
+    deprecated: bool,
    trigger_call_info: Option<bool>,
-    score: Option<CompletionScore>,
+    relevance: CompletionRelevance,
-    ref_match: Option<(Mutability, CompletionScore)>,
+    ref_match: Option<Mutability>,
 }
 impl Builder {
@@ -355,49 +419,49 @@ impl Builder {
            lookup,
            kind: self.kind,
            completion_kind: self.completion_kind,
-            deprecated: self.deprecated.unwrap_or(false),
+            deprecated: self.deprecated,
            trigger_call_info: self.trigger_call_info.unwrap_or(false),
-            score: self.score,
+            relevance: self.relevance,
            ref_match: self.ref_match,
            import_to_add: self.import_to_add,
        }
    }
-    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
+    pub(crate) fn lookup_by(&mut self, lookup: impl Into<String>) -> &mut Builder {
        self.lookup = Some(lookup.into());
        self
    }
-    pub(crate) fn label(mut self, label: impl Into<String>) -> Builder {
+    pub(crate) fn label(&mut self, label: impl Into<String>) -> &mut Builder {
        self.label = label.into();
        self
    }
-    pub(crate) fn insert_text(mut self, insert_text: impl Into<String>) -> Builder {
+    pub(crate) fn insert_text(&mut self, insert_text: impl Into<String>) -> &mut Builder {
        self.insert_text = Some(insert_text.into());
        self
    }
    pub(crate) fn insert_snippet(
-        mut self,
+        &mut self,
        _cap: SnippetCap,
        snippet: impl Into<String>,
-    ) -> Builder {
+    ) -> &mut Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.insert_text(snippet)
    }
-    pub(crate) fn kind(mut self, kind: impl Into<CompletionItemKind>) -> Builder {
+    pub(crate) fn kind(&mut self, kind: impl Into<CompletionItemKind>) -> &mut Builder {
        self.kind = Some(kind.into());
        self
    }
-    pub(crate) fn text_edit(mut self, edit: TextEdit) -> Builder {
+    pub(crate) fn text_edit(&mut self, edit: TextEdit) -> &mut Builder {
        self.text_edit = Some(edit);
        self
    }
-    pub(crate) fn snippet_edit(mut self, _cap: SnippetCap, edit: TextEdit) -> Builder {
+    pub(crate) fn snippet_edit(&mut self, _cap: SnippetCap, edit: TextEdit) -> &mut Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.text_edit(edit)
    }
-    pub(crate) fn detail(self, detail: impl Into<String>) -> Builder {
+    pub(crate) fn detail(&mut self, detail: impl Into<String>) -> &mut Builder {
        self.set_detail(Some(detail))
    }
-    pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
+    pub(crate) fn set_detail(&mut self, detail: Option<impl Into<String>>) -> &mut Builder {
        self.detail = detail.map(Into::into);
        if let Some(detail) = &self.detail {
            if never!(detail.contains('\n'), "multiline detail:\n{}", detail) {
@@ -407,34 +471,91 @@ impl Builder {
        self
    }
    #[allow(unused)]
-    pub(crate) fn documentation(self, docs: Documentation) -> Builder {
+    pub(crate) fn documentation(&mut self, docs: Documentation) -> &mut Builder {
        self.set_documentation(Some(docs))
    }
-    pub(crate) fn set_documentation(mut self, docs: Option<Documentation>) -> Builder {
+    pub(crate) fn set_documentation(&mut self, docs: Option<Documentation>) -> &mut Builder {
        self.documentation = docs.map(Into::into);
        self
    }
-    pub(crate) fn set_deprecated(mut self, deprecated: bool) -> Builder {
+    pub(crate) fn set_deprecated(&mut self, deprecated: bool) -> &mut Builder {
-        self.deprecated = Some(deprecated);
+        self.deprecated = deprecated;
        self
    }
-    pub(crate) fn set_score(mut self, score: CompletionScore) -> Builder {
+    pub(crate) fn set_relevance(&mut self, relevance: CompletionRelevance) -> &mut Builder {
-        self.score = Some(score);
+        self.relevance = relevance;
        self
    }
-    pub(crate) fn trigger_call_info(mut self) -> Builder {
+    pub(crate) fn trigger_call_info(&mut self) -> &mut Builder {
        self.trigger_call_info = Some(true);
        self
    }
-    pub(crate) fn add_import(mut self, import_to_add: Option<ImportEdit>) -> Builder {
+    pub(crate) fn add_import(&mut self, import_to_add: Option<ImportEdit>) -> &mut Builder {
        self.import_to_add = import_to_add;
        self
    }
-    pub(crate) fn set_ref_match(
+    pub(crate) fn ref_match(&mut self, mutability: Mutability) -> &mut Builder {
-        mut self,
+        self.ref_match = Some(mutability);
-        ref_match: Option<(Mutability, CompletionScore)>,
-    ) -> Builder {
-        self.ref_match = ref_match;
        self
    }
 }
+#[cfg(test)]
+mod tests {
+    use itertools::Itertools;
+    use test_utils::assert_eq_text;
+    use super::CompletionRelevance;
+    /// Check that these are CompletionRelevance are sorted in ascending order
+    /// by their relevance score.
+    ///
+    /// We want to avoid making assertions about the absolute score of any
+    /// item, but we do want to assert whether each is >, <, or == to the
+    /// others.
+    ///
+    /// If provided vec![vec![a], vec![b, c], vec![d]], then this will assert:
+    ///     a.score < b.score == c.score < d.score
+    fn check_relevance_score_ordered(expected_relevance_order: Vec<Vec<CompletionRelevance>>) {
+        let expected = format!("{:#?}", &expected_relevance_order);
+        let actual_relevance_order = expected_relevance_order
+            .into_iter()
+            .flatten()
+            .map(|r| (r.score(), r))
+            .sorted_by_key(|(score, _r)| *score)
+            .fold(
+                (u32::MIN, vec![vec![]]),
+                |(mut currently_collecting_score, mut out), (score, r)| {
+                    if currently_collecting_score == score {
+                        out.last_mut().unwrap().push(r);
+                    } else {
+                        currently_collecting_score = score;
+                        out.push(vec![r]);
+                    }
+                    (currently_collecting_score, out)
+                },
+            )
+            .1;
+        let actual = format!("{:#?}", &actual_relevance_order);
+        assert_eq_text!(&expected, &actual);
+    }
+    #[test]
+    fn relevance_score() {
+        // This test asserts that the relevance score for these items is ascending, and
+        // that any items in the same vec have the same score.
+        let expected_relevance_order = vec![
+            vec![CompletionRelevance::default()],
+            vec![
+                CompletionRelevance { exact_name_match: true, ..CompletionRelevance::default() },
+                CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() },
+            ],
+            vec![CompletionRelevance { exact_name_match: true, exact_type_match: true }],
+        ];
+        check_relevance_score_ordered(expected_relevance_order);
+    }
+}
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index a0c8c374d..263554ecf 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -23,7 +23,7 @@ use crate::{completions::Completions, context::CompletionContext, item::Completi
 pub use crate::{
    config::CompletionConfig,
-    item::{CompletionItem, CompletionItemKind, CompletionScore, ImportEdit, InsertTextFormat},
+    item::{CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit, InsertTextFormat},
 };
 //FIXME: split the following feature into fine-grained features.
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index fae5685e2..db31896e5 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -20,8 +20,8 @@ use ide_db::{
 use syntax::TextRange;
 use crate::{
-    item::ImportEdit, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
+    item::{CompletionRelevance, ImportEdit},
-    CompletionScore,
+    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
 };
 use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
@@ -117,7 +117,7 @@ impl<'a> RenderContext<'a> {
        node.docs(self.db())
    }
-    fn active_name_and_type(&self) -> Option<(String, Type)> {
+    fn expected_name_and_type(&self) -> Option<(String, Type)> {
        if let Some(record_field) = &self.completion.record_field_syntax {
            cov_mark::hit!(record_field_type_match);
            let (struct_field, _local) = self.completion.sema.resolve_record_field(record_field)?;
@@ -149,24 +149,29 @@ impl<'a> Render<'a> {
            CompletionKind::Reference,
            self.ctx.source_range(),
            name.to_string(),
-        )
+        );
-        .kind(SymbolKind::Field)
+        item.kind(SymbolKind::Field)
-        .detail(ty.display(self.ctx.db()).to_string())
+            .detail(ty.display(self.ctx.db()).to_string())
-        .set_documentation(field.docs(self.ctx.db()))
+            .set_documentation(field.docs(self.ctx.db()))
-        .set_deprecated(is_deprecated);
+            .set_deprecated(is_deprecated);
-        if let Some(score) = compute_score(&self.ctx, &ty, &name.to_string()) {
+        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
-            item = item.set_score(score);
+            item.set_relevance(relevance);
        }
        item.build()
    }
    fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
-        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), field.to_string())
+        let mut item = CompletionItem::new(
-            .kind(SymbolKind::Field)
+            CompletionKind::Reference,
-            .detail(ty.display(self.ctx.db()).to_string())
+            self.ctx.source_range(),
-            .build()
+            field.to_string(),
+        );
+        item.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string());
+        item.build()
    }
    fn render_resolution(
@@ -225,15 +230,13 @@ impl<'a> Render<'a> {
                CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
            }
            ScopeDef::Unknown => {
-                let item = CompletionItem::new(
+                let mut item = CompletionItem::new(
                    CompletionKind::Reference,
                    self.ctx.source_range(),
                    local_name,
-                )
+                );
-                .kind(CompletionItemKind::UnresolvedReference)
+                item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add);
-                .add_import(import_to_add)
+                return Some(item.build());
-                .build();
-                return Some(item);
            }
        };
@@ -242,20 +245,27 @@ impl<'a> Render<'a> {
        if let ScopeDef::Local(local) = resolution {
            let ty = local.ty(self.ctx.db());
            if !ty.is_unknown() {
-                item = item.detail(ty.display(self.ctx.db()).to_string());
+                item.detail(ty.display(self.ctx.db()).to_string());
            }
        };
-        let mut ref_match = None;
        if let ScopeDef::Local(local) = resolution {
-            if let Some((active_name, active_type)) = self.ctx.active_name_and_type() {
+            let ty = local.ty(self.ctx.db());
-                let ty = local.ty(self.ctx.db());
+            if let Some(relevance) = compute_relevance(&self.ctx, &ty, &local_name) {
-                if let Some(score) =
+                item.set_relevance(relevance);
-                    compute_score_from_active(&active_type, &active_name, &ty, &local_name)
+            }
-                {
+            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
-                    item = item.set_score(score);
+                if let Some(ty_without_ref) = expected_type.remove_ref() {
+                    if ty_without_ref == ty {
+                        cov_mark::hit!(suggest_ref);
+                        let mutability = if expected_type.is_mutable_reference() {
+                            Mutability::Mut
+                        } else {
+                            Mutability::Shared
+                        };
+                        item.ref_match(mutability);
+                    }
                }
-                ref_match = refed_type_matches(&active_type, &active_name, &ty, &local_name);
            }
        }
@@ -274,22 +284,17 @@ impl<'a> Render<'a> {
                };
                if has_non_default_type_params {
                    cov_mark::hit!(inserts_angle_brackets_for_generics);
-                    item = item
+                    item.lookup_by(local_name.clone())
-                        .lookup_by(local_name.clone())
                        .label(format!("{}<…>", local_name))
                        .insert_snippet(cap, format!("{}<$0>", local_name));
                }
            }
        }
+        item.kind(kind)
-        Some(
+            .add_import(import_to_add)
-            item.kind(kind)
+            .set_documentation(self.docs(resolution))
-                .add_import(import_to_add)
+            .set_deprecated(self.is_deprecated(resolution));
-                .set_ref_match(ref_match)
+        Some(item.build())
-                .set_documentation(self.docs(resolution))
-                .set_deprecated(self.is_deprecated(resolution))
-                .build(),
-        )
    }
    fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -317,45 +322,13 @@ impl<'a> Render<'a> {
    }
 }
-fn compute_score_from_active(
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<CompletionRelevance> {
-    active_type: &Type,
+    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
-    active_name: &str,
+    let mut res = CompletionRelevance::default();
-    ty: &Type,
+    res.exact_type_match = ty == &expected_type;
-    name: &str,
+    res.exact_name_match = name == &expected_name;
-) -> Option<CompletionScore> {
-    // Compute score
-    // For the same type
-    if active_type != ty {
-        return None;
-    }
-    let mut res = CompletionScore::TypeMatch;
-    // If same type + same name then go top position
-    if active_name == name {
-        res = CompletionScore::TypeAndNameMatch
-    }
    Some(res)
 }
-fn refed_type_matches(
-    active_type: &Type,
-    active_name: &str,
-    ty: &Type,
-    name: &str,
-) -> Option<(Mutability, CompletionScore)> {
-    let derefed_active = active_type.remove_ref()?;
-    let score = compute_score_from_active(&derefed_active, &active_name, &ty, &name)?;
-    Some((
-        if active_type.is_mutable_reference() { Mutability::Mut } else { Mutability::Shared },
-        score,
-    ))
-}
-fn compute_score(ctx: &RenderContext, ty: &Type, name: &str) -> Option<CompletionScore> {
-    let (active_name, active_type) = ctx.active_name_and_type()?;
-    compute_score_from_active(&active_type, &active_name, ty, name)
-}
 #[cfg(test)]
 mod tests {
@@ -365,7 +338,7 @@ mod tests {
    use crate::{
        test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
-        CompletionKind, CompletionScore,
+        CompletionKind, CompletionRelevance,
    };
    fn check(ra_fixture: &str, expect: Expect) {
@@ -373,24 +346,27 @@ mod tests {
        expect.assert_debug_eq(&actual);
    }
-    fn check_scores(ra_fixture: &str, expect: Expect) {
+    fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_score(score: Option<CompletionScore>) -> &'static str {
+        fn display_relevance(relevance: CompletionRelevance) -> &'static str {
-            match score {
+            match relevance {
-                Some(CompletionScore::TypeMatch) => "[type]",
+                CompletionRelevance { exact_type_match: true, exact_name_match: true } => {
-                Some(CompletionScore::TypeAndNameMatch) => "[type+name]",
+                    "[type+name]"
-                None => "[]".into(),
+                }
+                CompletionRelevance { exact_type_match: true, exact_name_match: false } => "[type]",
+                CompletionRelevance { exact_type_match: false, exact_name_match: true } => "[name]",
+                CompletionRelevance { exact_type_match: false, exact_name_match: false } => "[]",
            }
        }
        let mut completions = get_all_items(TEST_CONFIG, ra_fixture);
-        completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string()));
+        completions.sort_by_key(|it| (Reverse(it.relevance()), it.label().to_string()));
        let actual = completions
            .into_iter()
            .filter(|it| it.completion_kind == CompletionKind::Reference)
            .map(|it| {
                let tag = it.kind().unwrap().tag();
-                let score = display_score(it.score());
+                let relevance = display_relevance(it.relevance());
-                format!("{} {} {}\n", tag, it.label(), score)
+                format!("{} {} {}\n", tag, it.label(), relevance)
            })
            .collect::<String>();
        expect.assert_eq(&actual);
@@ -853,9 +829,9 @@ fn foo(xs: Vec<i128>)
    }
    #[test]
-    fn active_param_score() {
+    fn active_param_relevance() {
        cov_mark::check!(active_param_type_match);
-        check_scores(
+        check_relevance(
            r#"
 struct S { foo: i64, bar: u32, baz: u32 }
 fn test(bar: u32) { }
@@ -870,9 +846,9 @@ fn foo(s: S) { test(s.$0) }
    }
    #[test]
-    fn record_field_scores() {
+    fn record_field_relevances() {
        cov_mark::check!(record_field_type_match);
-        check_scores(
+        check_relevance(
            r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -887,8 +863,8 @@ fn foo(a: A) { B { bar: a.$0 }; }
    }
    #[test]
-    fn record_field_and_call_scores() {
+    fn record_field_and_call_relevances() {
-        check_scores(
+        check_relevance(
            r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -901,7 +877,7 @@ fn foo(a: A) { B { bar: f(a.$0) }; }
                fd baz []
            "#]],
        );
-        check_scores(
+        check_relevance(
            r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -918,7 +894,7 @@ fn foo(a: A) { f(B { bar: a.$0 }); }
    #[test]
    fn prioritize_exact_ref_match() {
-        check_scores(
+        check_relevance(
            r#"
 struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
@@ -933,7 +909,7 @@ fn go(world: &WorldSnapshot) { go(w$0) }
    #[test]
    fn too_many_arguments() {
-        check_scores(
+        check_relevance(
            r#"
 struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
@@ -945,4 +921,70 @@ fn f(foo: &Foo) { f(foo, w$0) }
            "#]],
        );
    }
+    #[test]
+    fn suggest_ref_mut() {
+        cov_mark::check!(suggest_ref);
+        check(
+            r#"
+struct S;
+fn foo(s: &mut S) {}
+fn main() {
+    let mut s = S;
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "S",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "S",
+                        kind: SymbolKind(
+                            Struct,
+                        ),
+                    },
+                    CompletionItem {
+                        label: "foo(…)",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "foo(${1:&mut s})$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "foo",
+                        detail: "-> ()",
+                        trigger_call_info: true,
+                    },
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "main()$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "main",
+                        detail: "-> ()",
+                    },
+                    CompletionItem {
+                        label: "s",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "s",
+                        kind: SymbolKind(
+                            Local,
+                        ),
+                        detail: "S",
+                        relevance: CompletionRelevance {
+                            exact_name_match: true,
+                            exact_type_match: false,
+                        },
+                        ref_match: "&mut ",
+                    },
+                ]
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/render/builder_ext.rs b/crates/ide_completion/src/render/builder_ext.rs
index 95a7596c1..6d062b3b9 100644
--- a/crates/ide_completion/src/render/builder_ext.rs
+++ b/crates/ide_completion/src/render/builder_ext.rs
@@ -52,11 +52,11 @@ impl Builder {
    }
    pub(super) fn add_call_parens(
-        mut self,
+        &mut self,
        ctx: &CompletionContext,
        name: String,
        params: Params,
-    ) -> Builder {
+    ) -> &mut Builder {
        if !self.should_add_parens(ctx) {
            return self;
        }
@@ -71,7 +71,7 @@ impl Builder {
        let (snippet, label) = if params.is_empty() {
            (format!("{}()$0", name), format!("{}()", name))
        } else {
-            self = self.trigger_call_info();
+            self.trigger_call_info();
            let snippet = match (ctx.config.add_call_argument_snippets, params) {
                (true, Params::Named(params)) => {
                    let function_params_snippet =
diff --git a/crates/ide_completion/src/render/const_.rs b/crates/ide_completion/src/render/const_.rs
index 5010b642a..8add369e4 100644
--- a/crates/ide_completion/src/render/const_.rs
+++ b/crates/ide_completion/src/render/const_.rs
@@ -36,17 +36,17 @@ impl<'a> ConstRender<'a> {
        let name = self.name()?;
        let detail = self.detail();
-        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
+        let mut item =
-            .kind(SymbolKind::Const)
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name);
+        item.kind(SymbolKind::Const)
            .set_documentation(self.ctx.docs(self.const_))
            .set_deprecated(
                self.ctx.is_deprecated(self.const_)
                    || self.ctx.is_deprecated_assoc_item(self.const_),
            )
-            .detail(detail)
+            .detail(detail);
-            .build();
-        Some(item)
+        Some(item.build())
    }
    fn name(&self) -> Option<String> {
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index ed055c1fb..e8cfcc0c7 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -55,27 +55,26 @@ impl<'a> EnumRender<'a> {
    }
    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
-        let mut builder = CompletionItem::new(
+        let mut item = CompletionItem::new(
            CompletionKind::Reference,
            self.ctx.source_range(),
            self.qualified_name.clone(),
-        )
+        );
-        .kind(SymbolKind::Variant)
+        item.kind(SymbolKind::Variant)
-        .set_documentation(self.variant.docs(self.ctx.db()))
+            .set_documentation(self.variant.docs(self.ctx.db()))
-        .set_deprecated(self.ctx.is_deprecated(self.variant))
+            .set_deprecated(self.ctx.is_deprecated(self.variant))
-        .add_import(import_to_add)
+            .add_import(import_to_add)
-        .detail(self.detail());
+            .detail(self.detail());
        if self.variant_kind == StructKind::Tuple {
            cov_mark::hit!(inserts_parens_for_tuple_enums);
            let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
-            builder =
+            item.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
-                builder.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
        } else if self.path.is_some() {
-            builder = builder.lookup_by(self.short_qualified_name);
+            item.lookup_by(self.short_qualified_name);
        }
-        builder.build()
+        item.build()
    }
    fn detail(&self) -> String {
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index 5931945a8..f4dabe3d1 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -41,16 +41,21 @@ impl<'a> FunctionRender<'a> {
    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
        let params = self.params();
-        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
+        let mut item = CompletionItem::new(
-            .kind(self.kind())
+            CompletionKind::Reference,
+            self.ctx.source_range(),
+            self.name.clone(),
+        );
+        item.kind(self.kind())
            .set_documentation(self.ctx.docs(self.func))
            .set_deprecated(
                self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
            )
            .detail(self.detail())
            .add_call_parens(self.ctx.completion, self.name, params)
-            .add_import(import_to_add)
+            .add_import(import_to_add);
-            .build()
+        item.build()
    }
    fn detail(&self) -> String {
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index a6cf3e479..3fa21ba7c 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -39,29 +39,31 @@ impl<'a> MacroRender<'a> {
    }
    fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
-        let mut builder =
+        let mut item =
-            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label())
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label());
-                .kind(SymbolKind::Macro)
+        item.kind(SymbolKind::Macro)
-                .set_documentation(self.docs.clone())
+            .set_documentation(self.docs.clone())
-                .set_deprecated(self.ctx.is_deprecated(self.macro_))
+            .set_deprecated(self.ctx.is_deprecated(self.macro_))
-                .add_import(import_to_add)
+            .add_import(import_to_add)
-                .set_detail(self.detail());
+            .set_detail(self.detail());
        let needs_bang = self.needs_bang();
-        builder = match self.ctx.snippet_cap() {
+        match self.ctx.snippet_cap() {
            Some(cap) if needs_bang => {
                let snippet = self.snippet();
                let lookup = self.lookup();
-                builder.insert_snippet(cap, snippet).lookup_by(lookup)
+                item.insert_snippet(cap, snippet).lookup_by(lookup);
+            }
+            None if needs_bang => {
+                item.insert_text(self.banged_name());
            }
-            None if needs_bang => builder.insert_text(self.banged_name()),
            _ => {
                cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
-                builder.insert_text(&self.name)
+                item.insert_text(&self.name);
            }
        };
-        Some(builder.build())
+        Some(item.build())
    }
    fn needs_bang(&self) -> bool {
diff --git a/crates/ide_completion/src/render/pattern.rs b/crates/ide_completion/src/render/pattern.rs
index 465dfe00c..ca2926125 100644
--- a/crates/ide_completion/src/render/pattern.rs
+++ b/crates/ide_completion/src/render/pattern.rs
@@ -69,19 +69,19 @@ fn build_completion(
    ctx: RenderContext<'_>,
    name: String,
    pat: String,
-    item: impl HasAttrs + Copy,
+    def: impl HasAttrs + Copy,
 ) -> CompletionItem {
-    let completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name)
+    let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name);
-        .kind(CompletionItemKind::Binding)
+    item.kind(CompletionItemKind::Binding)
-        .set_documentation(ctx.docs(item))
+        .set_documentation(ctx.docs(def))
-        .set_deprecated(ctx.is_deprecated(item))
+        .set_deprecated(ctx.is_deprecated(def))
        .detail(&pat);
-    let completion = if let Some(snippet_cap) = ctx.snippet_cap() {
+    if let Some(snippet_cap) = ctx.snippet_cap() {
-        completion.insert_snippet(snippet_cap, pat)
+        item.insert_snippet(snippet_cap, pat);
    } else {
-        completion.insert_text(pat)
+        item.insert_text(pat);
    };
-    completion.build()
+    item.build()
 }
 fn render_pat(
diff --git a/crates/ide_completion/src/render/type_alias.rs b/crates/ide_completion/src/render/type_alias.rs
index bd97c3692..e47b4c745 100644
--- a/crates/ide_completion/src/render/type_alias.rs
+++ b/crates/ide_completion/src/render/type_alias.rs
@@ -36,17 +36,17 @@ impl<'a> TypeAliasRender<'a> {
        let name = self.name()?;
        let detail = self.detail();
-        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
+        let mut item =
-            .kind(SymbolKind::TypeAlias)
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name);
+        item.kind(SymbolKind::TypeAlias)
            .set_documentation(self.ctx.docs(self.type_alias))
            .set_deprecated(
                self.ctx.is_deprecated(self.type_alias)
                    || self.ctx.is_deprecated_assoc_item(self.type_alias),
            )
-            .detail(detail)
+            .detail(detail);
-            .build();
-        Some(item)
+        Some(item.build())
    }
    fn name(&self) -> Option<String> {
diff --git a/crates/ide_db/Cargo.toml b/crates/ide_db/Cargo.toml
index 1f855c621..1f7a90d20 100644
--- a/crates/ide_db/Cargo.toml
+++ b/crates/ide_db/Cargo.toml
@@ -24,10 +24,10 @@ syntax = { path = "../syntax", version = "0.0.0" }
 text_edit = { path = "../text_edit", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 # ide 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_ssr/Cargo.toml b/crates/ide_ssr/Cargo.toml
index 315691f40..8c31df13a 100644
--- a/crates/ide_ssr/Cargo.toml
+++ b/crates/ide_ssr/Cargo.toml
@@ -19,7 +19,7 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 syntax = { path = "../syntax", 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_ssr/src/from_comment.rs b/crates/ide_ssr/src/from_comment.rs
new file mode 100644
index 000000000..f1b312284
--- /dev/null
+++ b/crates/ide_ssr/src/from_comment.rs
@@ -0,0 +1,32 @@
+//! This module allows building an SSR MatchFinder by parsing the SSR rule
+//! from a comment.
+use ide_db::{
+    base_db::{FilePosition, FileRange, SourceDatabase},
+    RootDatabase,
+};
+use syntax::{
+    ast::{self, AstNode, AstToken},
+    TextRange,
+};
+use crate::MatchFinder;
+/// Attempts to build an SSR MatchFinder from a comment at the given file
+/// range. If successful, returns the MatchFinder and a TextRange covering
+/// comment.
+pub fn ssr_from_comment(db: &RootDatabase, frange: FileRange) -> Option<(MatchFinder, TextRange)> {
+    let comment = {
+        let file = db.parse(frange.file_id);
+        file.tree().syntax().token_at_offset(frange.range.start()).find_map(ast::Comment::cast)
+    }?;
+    let comment_text_without_prefix = comment.text().strip_prefix(comment.prefix()).unwrap();
+    let ssr_rule = comment_text_without_prefix.parse().ok()?;
+    let lookup_context = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
+    let mut match_finder = MatchFinder::in_context(db, lookup_context, vec![]);
+    match_finder.add_rule(ssr_rule).ok()?;
+    Some((match_finder, comment.syntax().text_range()))
+}
diff --git a/crates/ide_ssr/src/lib.rs b/crates/ide_ssr/src/lib.rs
index a97fc8bca..00585f448 100644
--- a/crates/ide_ssr/src/lib.rs
+++ b/crates/ide_ssr/src/lib.rs
@@ -57,7 +57,17 @@
 //
 // | VS Code | **Rust Analyzer: Structural Search Replace**
 // |===
+//
+// Also available as an assist, by writing a comment containing the structural
+// search and replace rule. You will only see the assist if the comment can
+// be parsed as a valid structural search and replace rule.
+//
+// ```rust
+// // Place the cursor on the line below to see the assist 💡.
+// // foo($a, $b) ==>> ($a).foo($b)
+// ```
+mod from_comment;
 mod matching;
 mod nester;
 mod parsing;
@@ -71,6 +81,7 @@ mod tests;
 use crate::errors::bail;
 pub use crate::errors::SsrError;
+pub use crate::from_comment::ssr_from_comment;
 pub use crate::matching::Match;
 use crate::matching::MatchFailureReason;
 use hir::Semantics;
diff --git a/crates/mbe/Cargo.toml b/crates/mbe/Cargo.toml
index c7d5e39fa..139214207 100644
--- a/crates/mbe/Cargo.toml
+++ b/crates/mbe/Cargo.toml
@@ -18,8 +18,8 @@ log = "0.4.8"
 syntax = { path = "../syntax", version = "0.0.0" }
 parser = { path = "../parser", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
 [dev-dependencies]
 profile = { path = "../profile" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 6159d064c..6c0e22722 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -18,7 +18,7 @@
 //! // fn foo() {}
 //! ```
 //!
-//! After adding a new inline-test, run `cargo xtask codegen` to
+//! After adding a new inline-test, run `cargo test -p xtask` to
 //! extract it as a standalone text-fixture into
 //! `crates/syntax/test_data/parser/`, and run `cargo test` once to
 //! create the "gold" value.
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index f09726223..16fd56c7e 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -19,3 +19,6 @@ jod-thread = "0.1.1"
 tt = { path = "../tt", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
+snap = "1"
+object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+memmap = "0.7.0"
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 2ea456fb0..941d0fe9e 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -5,10 +5,12 @@
 //! is used to provide basic infrastructure for communication between two
 //! processes: Client (RA itself), Server (the external program)
-mod rpc;
-mod process;
 pub mod msg;
+mod process;
+mod rpc;
+mod version;
+use base_db::{Env, ProcMacro};
 use std::{
    ffi::OsStr,
    io,
@@ -16,7 +18,6 @@ use std::{
    sync::Arc,
 };
-use base_db::{Env, ProcMacro};
 use tt::{SmolStr, Subtree};
 use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
@@ -75,6 +76,21 @@ impl ProcMacroClient {
    }
    pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
+        match version::read_info(dylib_path) {
+            Ok(info) => {
+                if info.version.0 < 1 || info.version.1 < 47 {
+                    eprintln!("proc-macro {} built by {:#?} is not supported by Rust Analyzer, please update your rust version.", dylib_path.to_string_lossy(), info);
+                }
+            }
+            Err(err) => {
+                eprintln!(
+                    "proc-macro {} failed to find the given version. Reason: {}",
+                    dylib_path.to_string_lossy(),
+                    err
+                );
+            }
+        }
        let macros = match self.process.find_proc_macros(dylib_path) {
            Err(err) => {
                eprintln!("Failed to find proc macros. Error: {:#?}", err);
diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs
new file mode 100644
index 000000000..11a7fb59a
--- /dev/null
+++ b/crates/proc_macro_api/src/version.rs
@@ -0,0 +1,132 @@
+//! Reading proc-macro rustc version information from binary data
+use std::{
+    fs::File,
+    io::{self, Read},
+    path::Path,
+};
+use memmap::Mmap;
+use object::read::{File as BinaryFile, Object, ObjectSection};
+use snap::read::FrameDecoder as SnapDecoder;
+#[derive(Debug)]
+pub(crate) struct RustCInfo {
+    pub(crate) version: (usize, usize, usize),
+    pub(crate) channel: String,
+    pub(crate) commit: String,
+    pub(crate) date: String,
+}
+pub(crate) fn read_info(dylib_path: &Path) -> io::Result<RustCInfo> {
+    macro_rules! err {
+        ($e:literal) => {
+            io::Error::new(io::ErrorKind::InvalidData, $e)
+        };
+    }
+    let ver_str = read_version(dylib_path)?;
+    let mut items = ver_str.split_whitespace();
+    let tag = items.next().ok_or(err!("version format error"))?;
+    if tag != "rustc" {
+        return Err(err!("version format error (No rustc tag)"));
+    }
+    let version_part = items.next().ok_or(err!("no version string"))?;
+    let mut version_parts = version_part.split("-");
+    let version = version_parts.next().ok_or(err!("no version"))?;
+    let channel = version_parts.next().unwrap_or_default().to_string();
+    let commit = items.next().ok_or(err!("no commit info"))?;
+    // remove (
+    if commit.len() == 0 {
+        return Err(err!("commit format error"));
+    }
+    let commit = commit[1..].to_string();
+    let date = items.next().ok_or(err!("no date info"))?;
+    // remove )
+    if date.len() == 0 {
+        return Err(err!("date format error"));
+    }
+    let date = date[0..date.len() - 2].to_string();
+    let version_numbers = version
+        .split(".")
+        .map(|it| it.parse::<usize>())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| err!("version number error"))?;
+    if version_numbers.len() != 3 {
+        return Err(err!("version number format error"));
+    }
+    let version = (version_numbers[0], version_numbers[1], version_numbers[2]);
+    Ok(RustCInfo { version, channel, commit, date })
+}
+/// This is used inside read_version() to locate the ".rustc" section
+/// from a proc macro crate's binary file.
+fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> {
+    BinaryFile::parse(dylib_binary)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+        .section_by_name(section_name)
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))?
+        .data()
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+}
+/// Check the version of rustc that was used to compile a proc macro crate's
+///
+/// binary file.
+/// A proc macro crate binary's ".rustc" section has following byte layout:
+/// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes
+/// * ff060000 734e6150 is followed, it's the snappy format magic bytes,
+///   means bytes from here(including this sequence) are compressed in
+///   snappy compression format. Version info is inside here, so decompress
+///   this.
+/// The bytes you get after decompressing the snappy format portion has
+/// following layout:
+/// * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again)
+/// * [crate root bytes] next 4 bytes is to store crate root position,
+///   according to rustc's source code comment
+/// * [length byte] next 1 byte tells us how many bytes we should read next
+///   for the version string's utf8 bytes
+/// * [version string bytes encoded in utf8] <- GET THIS BOI
+/// * [some more bytes that we don really care but still there] :-)
+/// Check this issue for more about the bytes layout:
+/// https://github.com/rust-analyzer/rust-analyzer/issues/6174
+fn read_version(dylib_path: &Path) -> io::Result<String> {
+    let dylib_file = File::open(dylib_path)?;
+    let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?;
+    let dot_rustc = read_section(&dylib_mmaped, ".rustc")?;
+    let header = &dot_rustc[..8];
+    const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5];
+    // check if header is valid
+    if header != EXPECTED_HEADER {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("only metadata version 5 is supported, section header was: {:?}", header),
+        ));
+    }
+    let snappy_portion = &dot_rustc[8..];
+    let mut snappy_decoder = SnapDecoder::new(snappy_portion);
+    // the bytes before version string bytes, so this basically is:
+    // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5]
+    // 4 bytes for [crate root bytes]
+    // 1 byte for length of version string
+    // so 13 bytes in total, and we should check the 13th byte
+    // to know the length
+    let mut bytes_before_version = [0u8; 13];
+    snappy_decoder.read_exact(&mut bytes_before_version)?;
+    let length = bytes_before_version[12]; // what? can't use -1 indexing?
+    let mut version_string_utf8 = vec![0u8; length as usize];
+    snappy_decoder.read_exact(&mut version_string_utf8)?;
+    let version_string = String::from_utf8(version_string_utf8);
+    version_string.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+}
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 4c1b3036a..63b3f1532 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -17,9 +17,9 @@ memmap2 = "0.2.0"
 tt = { path = "../tt", version = "0.0.0" }
 mbe = { path = "../mbe", version = "0.0.0" }
 proc_macro_api = { path = "../proc_macro_api", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 cargo_metadata = "0.13"
 # used as proc macro test targets
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 25df13554..8af7871ac 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -395,6 +395,9 @@ impl Config {
    pub fn work_done_progress(&self) -> bool {
        try_or!(self.caps.window.as_ref()?.work_done_progress?, false)
    }
+    pub fn will_rename(&self) -> bool {
+        try_or!(self.caps.workspace.as_ref()?.file_operations.as_ref()?.will_rename?, false)
+    }
    pub fn code_action_resolve(&self) -> bool {
        try_or!(
            self.caps
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 2c4c339cb..6cc433cb8 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -799,8 +799,18 @@ pub(crate) fn handle_rename(
    let _p = profile::span("handle_rename");
    let position = from_proto::file_position(&snap, params.text_document_position)?;
-    let change =
+    let mut change =
        snap.analysis.rename(position, &*params.new_name)?.map_err(to_proto::rename_error)?;
+    // this is kind of a hack to prevent double edits from happening when moving files
+    // When a module gets renamed by renaming the mod declaration this causes the file to move
+    // which in turn will trigger a WillRenameFiles request to the server for which we reply with a
+    // a second identical set of renames, the client will then apply both edits causing incorrect edits
+    // with this we only emit source_file_edits in the WillRenameFiles response which will do the rename instead
+    // See https://github.com/microsoft/vscode-languageserver-node/issues/752 for more info
+    if !change.file_system_edits.is_empty() && snap.config.will_rename() {
+        change.source_file_edits.clear();
+    }
    let workspace_edit = to_proto::workspace_edit(&snap, change)?;
    Ok(Some(workspace_edit))
 }
@@ -1134,20 +1144,13 @@ pub(crate) fn handle_document_highlight(
        None
    };
-    let res = refs
+    let file_refs = refs.references.get(&position.file_id).map_or(&[][..], Vec::as_slice);
-        .references
+    let mut res = Vec::with_capacity(file_refs.len() + 1);
-        .get(&position.file_id)
+    res.extend(decl);
-        .map(|file_refs| {
+    res.extend(file_refs.iter().map(|&(range, access)| DocumentHighlight {
-            file_refs
+        range: to_proto::range(&line_index, range),
-                .into_iter()
+        kind: access.map(to_proto::document_highlight_kind),
-                .map(|&(range, access)| DocumentHighlight {
+    }));
-                    range: to_proto::range(&line_index, range),
-                    kind: access.map(to_proto::document_highlight_kind),
-                })
-                .chain(decl)
-                .collect()
-        })
-        .unwrap_or_default();
    Ok(Some(res))
 }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 4235eb6dd..1a8cdadad 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -6,9 +6,10 @@ use std::{
 use ide::{
    Annotation, AnnotationKind, Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind,
-    Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HlMod, HlPunct,
+    CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind,
-    HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat, Markup, NavigationTarget,
+    Highlight, HlMod, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat,
-    ReferenceAccess, RenameError, Runnable, Severity, SourceChange, TextEdit, TextRange, TextSize,
+    Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity, SourceChange,
+    TextEdit, TextRange, TextSize,
 };
 use ide_db::SymbolKind;
 use itertools::Itertools;
@@ -173,20 +174,14 @@ pub(crate) fn snippet_text_edit_vec(
 pub(crate) fn completion_item(
    line_index: &LineIndex,
-    completion_item: CompletionItem,
+    item: CompletionItem,
 ) -> Vec<lsp_types::CompletionItem> {
-    fn set_score(res: &mut lsp_types::CompletionItem, label: &str) {
-        res.preselect = Some(true);
-        // HACK: sort preselect items first
-        res.sort_text = Some(format!(" {}", label));
-    }
    let mut additional_text_edits = Vec::new();
    let mut text_edit = None;
    // LSP does not allow arbitrary edits in completion, so we have to do a
    // non-trivial mapping here.
-    let source_range = completion_item.source_range();
+    let source_range = item.source_range();
-    for indel in completion_item.text_edit().iter() {
+    for indel in item.text_edit().iter() {
        if indel.delete.contains_range(source_range) {
            text_edit = Some(if indel.delete == source_range {
                self::text_edit(line_index, indel.clone())
@@ -207,46 +202,61 @@ pub(crate) fn completion_item(
    }
    let text_edit = text_edit.unwrap();
-    let mut res = lsp_types::CompletionItem {
+    let mut lsp_item = lsp_types::CompletionItem {
-        label: completion_item.label().to_string(),
+        label: item.label().to_string(),
-        detail: completion_item.detail().map(|it| it.to_string()),
+        detail: item.detail().map(|it| it.to_string()),
-        filter_text: Some(completion_item.lookup().to_string()),
+        filter_text: Some(item.lookup().to_string()),
-        kind: completion_item.kind().map(completion_item_kind),
+        kind: item.kind().map(completion_item_kind),
        text_edit: Some(text_edit.into()),
        additional_text_edits: Some(additional_text_edits),
-        documentation: completion_item.documentation().map(documentation),
+        documentation: item.documentation().map(documentation),
-        deprecated: Some(completion_item.deprecated()),
+        deprecated: Some(item.deprecated()),
        ..Default::default()
    };
-    if completion_item.score().is_some() {
+    fn set_score(res: &mut lsp_types::CompletionItem, relevance: CompletionRelevance) {
-        set_score(&mut res, completion_item.label());
+        if relevance.is_relevant() {
+            res.preselect = Some(true);
+        }
+        // The relevance needs to be inverted to come up with a sort score
+        // because the client will sort ascending.
+        let sort_score = relevance.score() ^ 0xFF_FF_FF_FF;
+        // Zero pad the string to ensure values can be properly sorted
+        // by the client. Hex format is used because it is easier to
+        // visually compare very large values, which the sort text
+        // tends to be since it is the opposite of the score.
+        res.sort_text = Some(format!("{:08x}", sort_score));
    }
-    if completion_item.deprecated() {
+    set_score(&mut lsp_item, item.relevance());
-        res.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated])
+    if item.deprecated() {
+        lsp_item.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated])
    }
-    if completion_item.trigger_call_info() {
+    if item.trigger_call_info() {
-        res.command = Some(command::trigger_parameter_hints());
+        lsp_item.command = Some(command::trigger_parameter_hints());
    }
-    let mut all_results = match completion_item.ref_match() {
+    let mut res = match item.ref_match() {
-        Some(ref_match) => {
+        Some((mutability, relevance)) => {
-            let mut refed = res.clone();
+            let mut lsp_item_with_ref = lsp_item.clone();
-            let (mutability, _score) = ref_match;
+            set_score(&mut lsp_item_with_ref, relevance);
-            let label = format!("&{}{}", mutability.as_keyword_for_ref(), refed.label);
+            lsp_item_with_ref.label =
-            set_score(&mut refed, &label);
+                format!("&{}{}", mutability.as_keyword_for_ref(), lsp_item_with_ref.label);
-            refed.label = label;
+            if let Some(lsp_types::CompletionTextEdit::Edit(it)) = &mut lsp_item_with_ref.text_edit
-            vec![res, refed]
+            {
+                it.new_text = format!("&{}{}", mutability.as_keyword_for_ref(), it.new_text);
+            }
+            vec![lsp_item_with_ref, lsp_item]
        }
-        None => vec![res],
+        None => vec![lsp_item],
    };
-    for mut r in all_results.iter_mut() {
+    for lsp_item in res.iter_mut() {
-        r.insert_text_format = Some(insert_text_format(completion_item.insert_text_format()));
+        lsp_item.insert_text_format = Some(insert_text_format(item.insert_text_format()));
    }
-    all_results
+    res
 }
 pub(crate) fn signature_help(
@@ -1105,13 +1115,15 @@ mod tests {
        expect_test::expect![[r#"
            [
                (
-                    "arg",
+                    "&arg",
-                    None,
+                    Some(
+                        "fffffffd",
+                    ),
                ),
                (
-                    "&arg",
+                    "arg",
                    Some(
-                        " &arg",
+                        "fffffffe",
                    ),
                ),
            ]
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 33bde099b..05fca5dc4 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -14,7 +14,7 @@ doctest = false
 cov-mark = "1.1"
 itertools = "0.10.0"
 rowan = "0.12.2"
-rustc_lexer = { version = "709.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "710.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"