60 files changed, 1874 insertions, 2084 deletions

diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 6ce377710..7d5d12e63 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -128,6 +128,7 @@ impl ChangeFixture {
                     file_id,
                     meta.edition,
                     Some(crate_name.clone().into()),
+                    meta.cfg.clone(),
                     meta.cfg,
                     meta.env,
                     Default::default(),
@@ -157,6 +158,7 @@ impl ChangeFixture {
                 crate_root,
                 Edition::Edition2018,
                 Some(CrateName::new("test").unwrap().into()),
+                default_cfg.clone(),
                 default_cfg,
                 Env::default(),
                 Default::default(),
@@ -186,6 +188,7 @@ impl ChangeFixture {
                 Edition::Edition2021,
                 Some(CrateDisplayName::from_canonical_name("core".to_string())),
                 CfgOptions::default(),
+                CfgOptions::default(),
                 Env::default(),
                 Vec::new(),
             );
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 23cb0c839..0c51a59a0 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -189,6 +189,7 @@ pub struct CrateData {
     /// `Dependency` matters), this name should only be used for UI.
     pub display_name: Option<CrateDisplayName>,
     pub cfg_options: CfgOptions,
+    pub potential_cfg_options: CfgOptions,
     pub env: Env,
     pub dependencies: Vec<Dependency>,
     pub proc_macro: Vec<ProcMacro>,
@@ -219,6 +220,7 @@ impl CrateGraph {
         edition: Edition,
         display_name: Option<CrateDisplayName>,
         cfg_options: CfgOptions,
+        potential_cfg_options: CfgOptions,
         env: Env,
         proc_macro: Vec<ProcMacro>,
     ) -> CrateId {
@@ -227,6 +229,7 @@ impl CrateGraph {
             edition,
             display_name,
             cfg_options,
+            potential_cfg_options,
             env,
             proc_macro,
             dependencies: Vec::new(),
@@ -504,6 +507,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -512,6 +516,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -520,6 +525,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -536,6 +542,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -544,6 +551,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -559,6 +567,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -567,6 +576,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -575,6 +585,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -590,6 +601,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
@@ -598,6 +610,7 @@ mod tests {
             Edition2018,
             None,
             CfgOptions::default(),
+            CfgOptions::default(),
             Env::default(),
             Default::default(),
         );
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index 03b8dd767..9a4baa636 100644
--- a/crates/cfg/src/lib.rs
+++ b/crates/cfg/src/lib.rs
@@ -1,4 +1,4 @@
-//! cfg defines conditional compiling options, `cfg` attibute parser and evaluator
+//! cfg defines conditional compiling options, `cfg` attribute parser and evaluator
 
 mod cfg_expr;
 mod dnf;
@@ -50,8 +50,29 @@ impl CfgOptions {
             self.enabled.remove(&atom);
         }
     }
+
+    pub fn get_cfg_keys(&self) -> Vec<&SmolStr> {
+        self.enabled
+            .iter()
+            .map(|x| match x {
+                CfgAtom::Flag(key) => key,
+                CfgAtom::KeyValue { key, .. } => key,
+            })
+            .collect()
+    }
+
+    pub fn get_cfg_values(&self, cfg_key: &str) -> Vec<&SmolStr> {
+        self.enabled
+            .iter()
+            .filter_map(|x| match x {
+                CfgAtom::KeyValue { key, value } if cfg_key == key => Some(value),
+                _ => None,
+            })
+            .collect()
+    }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CfgDiff {
     // Invariants: No duplicates, no atom that's both in `enable` and `disable`.
     enable: Vec<CfgAtom>,
@@ -59,6 +80,20 @@ pub struct CfgDiff {
 }
 
 impl CfgDiff {
+    /// Create a new CfgDiff. Will return None if the same item appears more than once in the set
+    /// of both.
+    pub fn new(enable: Vec<CfgAtom>, disable: Vec<CfgAtom>) -> Option<CfgDiff> {
+        let mut occupied = FxHashSet::default();
+        for item in enable.iter().chain(disable.iter()) {
+            if !occupied.insert(item) {
+                // was present
+                return None;
+            }
+        }
+
+        Some(CfgDiff { enable, disable })
+    }
+
     /// Returns the total number of atoms changed by this diff.
     pub fn len(&self) -> usize {
         self.enable.len() + self.disable.len()
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index b7eabaabb..30cc34403 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -219,8 +219,7 @@ impl Crate {
         let doc_url = doc_attr_q.tt_values().map(|tt| {
             let name = tt.token_trees.iter()
                 .skip_while(|tt| !matches!(tt, TokenTree::Leaf(Leaf::Ident(Ident{text: ref ident, ..})) if ident == "html_root_url"))
-                .skip(2)
-                .next();
+                .nth(2);
 
             match name {
                 Some(TokenTree::Leaf(Leaf::Literal(Literal{ref text, ..}))) => Some(text),
@@ -234,6 +233,10 @@ impl Crate {
     pub fn cfg(&self, db: &dyn HirDatabase) -> CfgOptions {
         db.crate_graph()[self.id].cfg_options.clone()
     }
+
+    pub fn potential_cfg(&self, db: &dyn HirDatabase) -> CfgOptions {
+        db.crate_graph()[self.id].potential_cfg_options.clone()
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1846,7 +1849,7 @@ impl TypeParam {
 
     pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
         db.generic_predicates_for_param(self.id)
-            .into_iter()
+            .iter()
             .filter_map(|pred| match &pred.skip_binders().skip_binders() {
                 hir_ty::WhereClause::Implemented(trait_ref) => {
                     Some(Trait::from(trait_ref.hir_trait_id()))
@@ -1951,7 +1954,7 @@ impl Impl {
             all.extend(
                 db.inherent_impls_in_crate(id)
                     .for_self_ty(&ty)
-                    .into_iter()
+                    .iter()
                     .cloned()
                     .map(Self::from)
                     .filter(filter),
@@ -2232,8 +2235,8 @@ impl Type {
     }
 
     pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
-        let adt_id = match self.ty.kind(&Interner) {
-            &TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
+        let adt_id = match *self.ty.kind(&Interner) {
+            TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
             _ => return false,
         };
 
@@ -2287,9 +2290,9 @@ impl Type {
     }
 
     pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        let (variant_id, substs) = match self.ty.kind(&Interner) {
-            &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
-            &TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
+        let (variant_id, substs) = match *self.ty.kind(&Interner) {
+            TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
+            TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
             _ => return Vec::new(),
         };
 
@@ -2488,20 +2491,17 @@ impl Type {
             cb: &mut impl FnMut(Type),
         ) {
             for pred in bounds {
-                match pred.skip_binders() {
-                    WhereClause::Implemented(trait_ref) => {
-                        cb(type_.clone());
-                        // skip the self type. it's likely the type we just got the bounds from
-                        for ty in trait_ref
-                            .substitution
-                            .iter(&Interner)
-                            .skip(1)
-                            .filter_map(|a| a.ty(&Interner))
-                        {
-                            walk_type(db, &type_.derived(ty.clone()), cb);
-                        }
+                if let WhereClause::Implemented(trait_ref) = pred.skip_binders() {
+                    cb(type_.clone());
+                    // skip the self type. it's likely the type we just got the bounds from
+                    for ty in trait_ref
+                        .substitution
+                        .iter(&Interner)
+                        .skip(1)
+                        .filter_map(|a| a.ty(&Interner))
+                    {
+                        walk_type(db, &type_.derived(ty.clone()), cb);
                     }
-                    _ => (),
                 }
             }
         }
@@ -2514,7 +2514,7 @@ impl Type {
                     walk_substs(db, type_, substs, cb);
                 }
                 TyKind::AssociatedType(_, substs) => {
-                    if let Some(_) = ty.associated_type_parent_trait(db) {
+                    if ty.associated_type_parent_trait(db).is_some() {
                         cb(type_.derived(ty.clone()));
                     }
                     walk_substs(db, type_, substs, cb);
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index bed4c4994..f6e6cdbe2 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -690,9 +690,7 @@ impl ExprCollector<'_> {
                 }
             }
             ast::Stmt::Item(item) => {
-                if self.check_cfg(&item).is_none() {
-                    return;
-                }
+                self.check_cfg(&item);
             }
         }
     }
@@ -717,7 +715,8 @@ impl ExprCollector<'_> {
         block.statements().for_each(|s| self.collect_stmt(s));
         block.tail_expr().and_then(|e| {
             let expr = self.maybe_collect_expr(e)?;
-            Some(self.statements_in_scope.push(Statement::Expr { expr, has_semi: false }))
+            self.statements_in_scope.push(Statement::Expr { expr, has_semi: false });
+            Some(())
         });
 
         let mut tail = None;
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 27d837d47..673a75386 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -15,12 +15,9 @@ fn lower(ra_fixture: &str) -> Arc<Body> {
     let mut fn_def = None;
     'outer: for (_, module) in def_map.modules() {
         for decl in module.scope.declarations() {
-            match decl {
-                ModuleDefId::FunctionId(it) => {
-                    fn_def = Some(it);
-                    break 'outer;
-                }
-                _ => {}
+            if let ModuleDefId::FunctionId(it) = decl {
+                fn_def = Some(it);
+                break 'outer;
             }
         }
     }
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 0f04b2bae..096ac7968 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -104,7 +104,7 @@ impl GenericParams {
     ) -> Interned<GenericParams> {
         let _p = profile::span("generic_params_query");
 
-        let generics = match def {
+        match def {
             GenericDefId::FunctionId(id) => {
                 let id = id.lookup(db).id;
                 let tree = id.item_tree(db);
@@ -150,8 +150,7 @@ impl GenericParams {
             GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => {
                 Interned::new(GenericParams::default())
             }
-        };
-        generics
+        }
     }
 
     fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 08407ebfa..567ae5660 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -241,10 +241,8 @@ impl ItemScope {
         check_changed!(changed, (self / def).values, glob_imports[lookup], def_import_type);
         check_changed!(changed, (self / def).macros, glob_imports[lookup], def_import_type);
 
-        if def.is_none() {
-            if self.unresolved.insert(lookup.1) {
-                changed = true;
-            }
+        if def.is_none() && self.unresolved.insert(lookup.1) {
+            changed = true;
         }
 
         changed
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index e63bc8232..8b12e5a67 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -30,16 +30,16 @@ pub(super) fn print_item_tree(tree: &ItemTree) -> String {
 
 macro_rules! w {
     ($dst:expr, $($arg:tt)*) => {
-        drop(write!($dst, $($arg)*))
+        { let _ = write!($dst, $($arg)*); }
     };
 }
 
 macro_rules! wln {
     ($dst:expr) => {
-        drop(writeln!($dst))
+        { let _ = writeln!($dst); }
     };
     ($dst:expr, $($arg:tt)*) => {
-        drop(writeln!($dst, $($arg)*))
+        { let _ = writeln!($dst, $($arg)*); }
     };
 }
 
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index ebfcc26c4..9e6aa9607 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -367,10 +367,7 @@ impl DefMap {
     pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {
         match &self[local_mod].parent {
             Some(parent) => Some(self.module_id(*parent)),
-            None => match &self.block {
-                Some(block) => Some(block.parent),
-                None => None,
-            },
+            None => self.block.as_ref().map(|block| block.parent),
         }
     }
 
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 629bc7952..229f57d77 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -55,7 +55,7 @@ impl ResolvePathResult {
         segment_index: Option<usize>,
         krate: Option<CrateId>,
     ) -> ResolvePathResult {
-        ResolvePathResult { resolved_def, reached_fixedpoint, segment_index, krate }
+        ResolvePathResult { resolved_def, segment_index, reached_fixedpoint, krate }
     }
 }
 
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 4cdb5913d..667092cd2 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -209,7 +209,7 @@ impl Path {
 
     pub fn is_self_type(&self) -> bool {
         self.type_anchor.is_none()
-            && self.generic_args == &[None]
+            && self.generic_args == [None]
             && self.mod_path.as_ident() == Some(&name!(Self))
     }
 }
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 49c573087..a11439c3b 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -388,9 +388,9 @@ impl Resolver {
         self.module_scope().map(|t| t.0.krate())
     }
 
-    pub fn where_predicates_in_scope<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = &'a crate::generics::WherePredicate> + 'a {
+    pub fn where_predicates_in_scope(
+        &self,
+    ) -> impl Iterator<Item = &crate::generics::WherePredicate> {
         self.scopes
             .iter()
             .rev()
@@ -464,16 +464,16 @@ impl Scope {
             &Scope::GenericParams { ref params, def: parent } => {
                 for (local_id, param) in params.types.iter() {
                     if let Some(ref name) = param.name {
-                        let id = TypeParamId { local_id, parent };
+                        let id = TypeParamId { parent, local_id };
                         f(name.clone(), ScopeDef::GenericParam(id.into()))
                     }
                 }
                 for (local_id, param) in params.consts.iter() {
-                    let id = ConstParamId { local_id, parent };
+                    let id = ConstParamId { parent, local_id };
                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
                 }
                 for (local_id, param) in params.lifetimes.iter() {
-                    let id = LifetimeParamId { local_id, parent };
+                    let id = LifetimeParamId { parent, local_id };
                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
                 }
             }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 4c83a2efe..f556bc751 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -420,7 +420,7 @@ fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
             tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(it),
             _ => None,
         })
-        .ok_or_else(|| mbe::ExpandError::ConversionError)
+        .ok_or(mbe::ExpandError::ConversionError)
 }
 
 fn include_expand(
@@ -432,9 +432,8 @@ fn include_expand(
         let path = parse_string(tt)?;
         let file_id = relative_file(db, arg_id, &path, false)?;
 
-        let subtree = parse_to_token_tree(&db.file_text(file_id))
-            .ok_or_else(|| mbe::ExpandError::ConversionError)?
-            .0;
+        let subtree =
+            parse_to_token_tree(&db.file_text(file_id)).ok_or(mbe::ExpandError::ConversionError)?.0;
         Ok((subtree, file_id))
     })();
 
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 584ddcf9f..66601f4df 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -128,7 +128,7 @@ pub fn expand_eager_macro(
         }),
         kind: MacroCallKind::FnLike { ast_id: call_id, fragment: FragmentKind::Expr },
     });
-    let arg_file_id: MacroCallId = arg_id;
+    let arg_file_id = arg_id;
 
     let parsed_args =
         diagnostic_sink.result(mbe::token_tree_to_syntax_node(&parsed_args, FragmentKind::Expr))?.0;
@@ -177,7 +177,7 @@ fn lazy_expand(
     let ast_id = db.ast_id_map(macro_call.file_id).ast_id(&macro_call.value);
 
     let fragment = crate::to_fragment_kind(&macro_call.value);
-    let id: MacroCallId = def.as_lazy_macro(
+    let id = def.as_lazy_macro(
         db,
         krate,
         MacroCallKind::FnLike { ast_id: macro_call.with_value(ast_id), fragment },
@@ -207,7 +207,7 @@ fn eager_macro_recur(
             .option_with(|| macro_resolver(child.path()?), || err("failed to resolve macro"))?;
         let insert = match def.kind {
             MacroDefKind::BuiltInEager(..) => {
-                let id: MacroCallId = expand_eager_macro(
+                let id = expand_eager_macro(
                     db,
                     krate,
                     curr.with_value(child.clone()),
diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index a4c09c742..a55b99de0 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -2,6 +2,7 @@
 //! about the code that Chalk needs.
 use std::sync::Arc;
 
+use cov_mark::hit;
 use log::debug;
 
 use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
@@ -106,7 +107,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         };
 
         fn local_impls(db: &dyn HirDatabase, module: ModuleId) -> Option<Arc<TraitImpls>> {
-            db.trait_impls_in_block(module.containing_block()?)
+            let block = module.containing_block()?;
+            hit!(block_local_impls);
+            db.trait_impls_in_block(block)
         }
 
         // Note: Since we're using impls_for_trait, only impls where the trait
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
index 4640ea821..b99a03492 100644
--- a/crates/hir_ty/src/test_db.rs
+++ b/crates/hir_ty/src/test_db.rs
@@ -86,16 +86,20 @@ impl FileLoader for TestDB {
 }
 
 impl TestDB {
-    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
+    pub(crate) fn module_for_file_opt(&self, file_id: FileId) -> Option<ModuleId> {
         for &krate in self.relevant_crates(file_id).iter() {
             let crate_def_map = self.crate_def_map(krate);
             for (local_id, data) in crate_def_map.modules() {
                 if data.origin.file_id() == Some(file_id) {
-                    return crate_def_map.module_id(local_id);
+                    return Some(crate_def_map.module_id(local_id));
                 }
             }
         }
-        panic!("Can't find module for file")
+        None
+    }
+
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
+        self.module_for_file_opt(file_id).unwrap()
     }
 
     pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index b873585c4..0651f34ae 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -11,23 +11,21 @@ mod incremental;
 
 use std::{collections::HashMap, env, sync::Arc};
 
-use base_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
+use base_db::{fixture::WithFixture, FileRange, SourceDatabaseExt};
 use expect_test::Expect;
 use hir_def::{
     body::{Body, BodySourceMap, SyntheticSyntax},
-    child_by_source::ChildBySource,
     db::DefDatabase,
+    expr::{ExprId, PatId},
     item_scope::ItemScope,
-    keys,
     nameres::DefMap,
     src::HasSource,
-    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
+    AssocItemId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
 use once_cell::race::OnceBool;
 use stdx::format_to;
 use syntax::{
-    algo,
     ast::{self, AstNode, NameOwner},
     SyntaxNode,
 };
@@ -59,51 +57,55 @@ fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> {
 }
 
 fn check_types(ra_fixture: &str) {
-    check_types_impl(ra_fixture, false)
+    check_impl(ra_fixture, false, true, false)
 }
 
 fn check_types_source_code(ra_fixture: &str) {
-    check_types_impl(ra_fixture, true)
-}
-
-fn check_types_impl(ra_fixture: &str, display_source: bool) {
-    let _tracing = setup_tracing();
-    let db = TestDB::with_files(ra_fixture);
-    let mut checked_one = false;
-    for (file_id, annotations) in db.extract_annotations() {
-        for (range, expected) in annotations {
-            let ty = type_at_range(&db, FileRange { file_id, range });
-            let actual = if display_source {
-                let module = db.module_for_file(file_id);
-                ty.display_source_code(&db, module).unwrap()
-            } else {
-                ty.display_test(&db).to_string()
-            };
-            assert_eq!(expected, actual);
-            checked_one = true;
-        }
-    }
-
-    assert!(checked_one, "no `//^` annotations found");
+    check_impl(ra_fixture, false, true, true)
 }
 
 fn check_no_mismatches(ra_fixture: &str) {
-    check_mismatches_impl(ra_fixture, true)
+    check_impl(ra_fixture, true, false, false)
 }
 
-#[allow(unused)]
-fn check_mismatches(ra_fixture: &str) {
-    check_mismatches_impl(ra_fixture, false)
+fn check(ra_fixture: &str) {
+    check_impl(ra_fixture, false, false, false)
 }
 
-fn check_mismatches_impl(ra_fixture: &str, allow_none: bool) {
+fn check_impl(ra_fixture: &str, allow_none: bool, only_types: bool, display_source: bool) {
     let _tracing = setup_tracing();
-    let (db, file_id) = TestDB::with_single_file(ra_fixture);
-    let module = db.module_for_file(file_id);
-    let def_map = module.def_map(&db);
+    let (db, files) = TestDB::with_many_files(ra_fixture);
+
+    let mut had_annotations = false;
+    let mut mismatches = HashMap::new();
+    let mut types = HashMap::new();
+    for (file_id, annotations) in db.extract_annotations() {
+        for (range, expected) in annotations {
+            let file_range = FileRange { file_id, range };
+            if only_types {
+                types.insert(file_range, expected);
+            } else if expected.starts_with("type: ") {
+                types.insert(file_range, expected.trim_start_matches("type: ").to_string());
+            } else if expected.starts_with("expected") {
+                mismatches.insert(file_range, expected);
+            } else {
+                panic!("unexpected annotation: {}", expected);
+            }
+            had_annotations = true;
+        }
+    }
+    assert!(had_annotations || allow_none, "no `//^` annotations found");
 
     let mut defs: Vec<DefWithBodyId> = Vec::new();
-    visit_module(&db, &def_map, module.local_id, &mut |it| defs.push(it));
+    for file_id in files {
+        let module = db.module_for_file_opt(file_id);
+        let module = match module {
+            Some(m) => m,
+            None => continue,
+        };
+        let def_map = module.def_map(&db);
+        visit_module(&db, &def_map, module.local_id, &mut |it| defs.push(it));
+    }
     defs.sort_by_key(|def| match def {
         DefWithBodyId::FunctionId(it) => {
             let loc = it.lookup(&db);
@@ -118,37 +120,59 @@ fn check_mismatches_impl(ra_fixture: &str, allow_none: bool) {
             loc.source(&db).value.syntax().text_range().start()
         }
     });
-    let mut mismatches = HashMap::new();
-    let mut push_mismatch = |src_ptr: InFile<SyntaxNode>, mismatch: TypeMismatch| {
-        let range = src_ptr.value.text_range();
-        if src_ptr.file_id.call_node(&db).is_some() {
-            panic!("type mismatch in macro expansion");
-        }
-        let file_range = FileRange { file_id: src_ptr.file_id.original_file(&db), range };
-        let actual = format!(
-            "expected {}, got {}",
-            mismatch.expected.display_test(&db),
-            mismatch.actual.display_test(&db)
-        );
-        mismatches.insert(file_range, actual);
-    };
+    let mut unexpected_type_mismatches = String::new();
     for def in defs {
         let (_body, body_source_map) = db.body_with_source_map(def);
         let inference_result = db.infer(def);
+
+        for (pat, ty) in inference_result.type_of_pat.iter() {
+            let node = match pat_node(&body_source_map, pat, &db) {
+                Some(value) => value,
+                None => continue,
+            };
+            let range = node.as_ref().original_file_range(&db);
+            if let Some(expected) = types.remove(&range) {
+                let actual = if display_source {
+                    ty.display_source_code(&db, def.module(&db)).unwrap()
+                } else {
+                    ty.display_test(&db).to_string()
+                };
+                assert_eq!(actual, expected);
+            }
+        }
+
+        for (expr, ty) in inference_result.type_of_expr.iter() {
+            let node = match expr_node(&body_source_map, expr, &db) {
+                Some(value) => value,
+                None => continue,
+            };
+            let range = node.as_ref().original_file_range(&db);
+            if let Some(expected) = types.remove(&range) {
+                let actual = if display_source {
+                    ty.display_source_code(&db, def.module(&db)).unwrap()
+                } else {
+                    ty.display_test(&db).to_string()
+                };
+                assert_eq!(actual, expected);
+            }
+        }
+
         for (pat, mismatch) in inference_result.pat_type_mismatches() {
-            let syntax_ptr = match body_source_map.pat_syntax(pat) {
-                Ok(sp) => {
-                    let root = db.parse_or_expand(sp.file_id).unwrap();
-                    sp.map(|ptr| {
-                        ptr.either(
-                            |it| it.to_node(&root).syntax().clone(),
-                            |it| it.to_node(&root).syntax().clone(),
-                        )
-                    })
-                }
-                Err(SyntheticSyntax) => continue,
+            let node = match pat_node(&body_source_map, pat, &db) {
+                Some(value) => value,
+                None => continue,
             };
-            push_mismatch(syntax_ptr, mismatch.clone());
+            let range = node.as_ref().original_file_range(&db);
+            let actual = format!(
+                "expected {}, got {}",
+                mismatch.expected.display_test(&db),
+                mismatch.actual.display_test(&db)
+            );
+            if let Some(annotation) = mismatches.remove(&range) {
+                assert_eq!(actual, annotation);
+            } else {
+                format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual);
+            }
         }
         for (expr, mismatch) in inference_result.expr_type_mismatches() {
             let node = match body_source_map.expr_syntax(expr) {
@@ -158,45 +182,70 @@ fn check_mismatches_impl(ra_fixture: &str, allow_none: bool) {
                 }
                 Err(SyntheticSyntax) => continue,
             };
-            push_mismatch(node, mismatch.clone());
-        }
-    }
-    let mut checked_one = false;
-    for (file_id, annotations) in db.extract_annotations() {
-        for (range, expected) in annotations {
-            let file_range = FileRange { file_id, range };
-            if let Some(mismatch) = mismatches.remove(&file_range) {
-                assert_eq!(mismatch, expected);
+            let range = node.as_ref().original_file_range(&db);
+            let actual = format!(
+                "expected {}, got {}",
+                mismatch.expected.display_test(&db),
+                mismatch.actual.display_test(&db)
+            );
+            if let Some(annotation) = mismatches.remove(&range) {
+                assert_eq!(actual, annotation);
             } else {
-                assert!(false, "Expected mismatch not encountered: {}\n", expected);
+                format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual);
             }
-            checked_one = true;
         }
     }
+
     let mut buf = String::new();
-    for (range, mismatch) in mismatches {
-        format_to!(buf, "{:?}: {}\n", range.range, mismatch,);
+    if !unexpected_type_mismatches.is_empty() {
+        format_to!(buf, "Unexpected type mismatches:\n{}", unexpected_type_mismatches);
+    }
+    if !mismatches.is_empty() {
+        format_to!(buf, "Unchecked mismatch annotations:\n");
+        for m in mismatches {
+            format_to!(buf, "{:?}: {}\n", m.0.range, m.1);
+        }
     }
-    assert!(buf.is_empty(), "Unexpected type mismatches:\n{}", buf);
+    if !types.is_empty() {
+        format_to!(buf, "Unchecked type annotations:\n");
+        for t in types {
+            format_to!(buf, "{:?}: type {}\n", t.0.range, t.1);
+        }
+    }
+    assert!(buf.is_empty(), "{}", buf);
+}
 
-    assert!(checked_one || allow_none, "no `//^` annotations found");
+fn expr_node(
+    body_source_map: &BodySourceMap,
+    expr: ExprId,
+    db: &TestDB,
+) -> Option<InFile<SyntaxNode>> {
+    Some(match body_source_map.expr_syntax(expr) {
+        Ok(sp) => {
+            let root = db.parse_or_expand(sp.file_id).unwrap();
+            sp.map(|ptr| ptr.to_node(&root).syntax().clone())
+        }
+        Err(SyntheticSyntax) => return None,
+    })
 }
 
-fn type_at_range(db: &TestDB, pos: FileRange) -> Ty {
-    let file = db.parse(pos.file_id).ok().unwrap();
-    let expr = algo::find_node_at_range::<ast::Expr>(file.syntax(), pos.range).unwrap();
-    let fn_def = expr.syntax().ancestors().find_map(ast::Fn::cast).unwrap();
-    let module = db.module_for_file(pos.file_id);
-    let func = *module.child_by_source(db)[keys::FUNCTION]
-        .get(&InFile::new(pos.file_id.into(), fn_def))
-        .unwrap();
-
-    let (_body, source_map) = db.body_with_source_map(func.into());
-    if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
-        let infer = db.infer(func.into());
-        return infer[expr_id].clone();
-    }
-    panic!("Can't find expression")
+fn pat_node(
+    body_source_map: &BodySourceMap,
+    pat: PatId,
+    db: &TestDB,
+) -> Option<InFile<SyntaxNode>> {
+    Some(match body_source_map.pat_syntax(pat) {
+        Ok(sp) => {
+            let root = db.parse_or_expand(sp.file_id).unwrap();
+            sp.map(|ptr| {
+                ptr.either(
+                    |it| it.to_node(&root).syntax().clone(),
+                    |it| it.to_node(&root).syntax().clone(),
+                )
+            })
+        }
+        Err(SyntheticSyntax) => return None,
+    })
 }
 
 fn infer(ra_fixture: &str) -> String {
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index 713b74165..87089f09d 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -1,27 +1,22 @@
-use expect_test::expect;
-
-use super::{check_infer, check_infer_with_mismatches, check_no_mismatches, check_types};
+use super::{check, check_no_mismatches, check_types};
 
 #[test]
-fn infer_block_expr_type_mismatch() {
-    check_infer(
+fn block_expr_type_mismatch() {
+    // FIXME fix double type mismatch
+    check(
         r"
-        fn test() {
-            let a: i32 = { 1i64 };
-        }
+fn test() {
+    let a: i32 = { 1i64 };
+              // ^^^^^^^^ expected i32, got i64
+                // ^^^^ expected i32, got i64
+}
         ",
-        expect![[r"
-            10..40 '{     ...4 }; }': ()
-            20..21 'a': i32
-            29..37 '{ 1i64 }': i64
-            31..35 '1i64': i64
-        "]],
     );
 }
 
 #[test]
 fn coerce_places() {
-    check_infer(
+    check_no_mismatches(
         r#"
 //- minicore: coerce_unsized
 struct S<T> { a: T }
@@ -46,81 +41,25 @@ fn test2() {
     let g: (&[_], &[_]) = (arr, arr);
 }
 "#,
-        expect![[r#"
-            30..31 '_': &[T]
-            44..55 '{ loop {} }': T
-            46..53 'loop {}': !
-            51..53 '{}': ()
-            64..65 '_': S<&[T]>
-            81..92 '{ loop {} }': T
-            83..90 'loop {}': !
-            88..90 '{}': ()
-            121..132 '{ loop {} }': *mut [T; 2]
-            123..130 'loop {}': !
-            128..130 '{}': ()
-            159..172 '{     gen() }': *mut [U]
-            165..168 'gen': fn gen<U>() -> *mut [U; 2]
-            165..170 'gen()': *mut [U; 2]
-            185..419 '{     ...rr); }': ()
-            195..198 'arr': &[u8; 1]
-            211..215 '&[1]': &[u8; 1]
-            212..215 '[1]': [u8; 1]
-            213..214 '1': u8
-            226..227 'a': &[u8]
-            236..239 'arr': &[u8; 1]
-            249..250 'b': u8
-            253..254 'f': fn f<u8>(&[u8]) -> u8
-            253..259 'f(arr)': u8
-            255..258 'arr': &[u8; 1]
-            269..270 'c': &[u8]
-            279..286 '{ arr }': &[u8]
-            281..284 'arr': &[u8; 1]
-            296..297 'd': u8
-            300..301 'g': fn g<u8>(S<&[u8]>) -> u8
-            300..315 'g(S { a: arr })': u8
-            302..314 'S { a: arr }': S<&[u8]>
-            309..312 'arr': &[u8; 1]
-            325..326 'e': [&[u8]; 1]
-            340..345 '[arr]': [&[u8]; 1]
-            341..344 'arr': &[u8; 1]
-            355..356 'f': [&[u8]; 2]
-            370..378 '[arr; 2]': [&[u8]; 2]
-            371..374 'arr': &[u8; 1]
-            376..377 '2': usize
-            388..389 'g': (&[u8], &[u8])
-            406..416 '(arr, arr)': (&[u8], &[u8])
-            407..410 'arr': &[u8; 1]
-            412..415 'arr': &[u8; 1]
-        "#]],
     );
 }
 
 #[test]
-fn infer_let_stmt_coerce() {
-    check_infer(
+fn let_stmt_coerce() {
+    check_no_mismatches(
         r"
-        fn test() {
-            let x: &[isize] = &[1];
-            let x: *const [isize] = &[1];
-        }
-        ",
-        expect![[r#"
-            10..75 '{     ...[1]; }': ()
-            20..21 'x': &[isize]
-            34..38 '&[1]': &[isize; 1]
-            35..38 '[1]': [isize; 1]
-            36..37 '1': isize
-            48..49 'x': *const [isize]
-            68..72 '&[1]': &[isize; 1]
-            69..72 '[1]': [isize; 1]
-            70..71 '1': isize
-        "#]],
+//- minicore: coerce_unsized
+fn test() {
+    let x: &[isize] = &[1];
+    let x: *const [isize] = &[1];
+}
+",
     );
 }
 
 #[test]
-fn infer_custom_coerce_unsized() {
-    check_infer(
+fn custom_coerce_unsized() {
+    check(
         r#"
 //- minicore: coerce_unsized
 use core::{marker::Unsize, ops::CoerceUnsized};
@@ -138,46 +77,22 @@ fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
 
 fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
     let d = foo1(a);
+              // ^ expected A<[{unknown}]>, got A<[u8; 2]>
     let e = foo2(b);
+     // ^ type: B<[u8]>
     let f = foo3(c);
+     // ^ type: C<[u8]>
 }
 "#,
-        expect![[r#"
-            306..307 'x': A<[T]>
-            327..332 '{ x }': A<[T]>
-            329..330 'x': A<[T]>
-            344..345 'x': B<[T]>
-            365..370 '{ x }': B<[T]>
-            367..368 'x': B<[T]>
-            382..383 'x': C<[T]>
-            403..408 '{ x }': C<[T]>
-            405..406 'x': C<[T]>
-            418..419 'a': A<[u8; 2]>
-            433..434 'b': B<[u8; 2]>
-            448..449 'c': C<[u8; 2]>
-            463..529 '{     ...(c); }': ()
-            473..474 'd': A<[{unknown}]>
-            477..481 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
-            477..484 'foo1(a)': A<[{unknown}]>
-            482..483 'a': A<[u8; 2]>
-            494..495 'e': B<[u8]>
-            498..502 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
-            498..505 'foo2(b)': B<[u8]>
-            503..504 'b': B<[u8; 2]>
-            515..516 'f': C<[u8]>
-            519..523 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
-            519..526 'foo3(c)': C<[u8]>
-            524..525 'c': C<[u8; 2]>
-        "#]],
     );
 }
 
 #[test]
-fn infer_if_coerce() {
-    check_infer(
+fn if_coerce() {
+    check_no_mismatches(
         r#"
-//- minicore: unsize
-fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
+fn foo<T>(x: &[T]) -> &[T] { x }
 fn test() {
     let x = if true {
         foo(&[1])
@@ -186,35 +101,15 @@ fn test() {
     };
 }
 "#,
-        expect![[r#"
-            10..11 'x': &[T]
-            27..38 '{ loop {} }': &[T]
-            29..36 'loop {}': !
-            34..36 '{}': ()
-            49..125 '{     ...  }; }': ()
-            59..60 'x': &[i32]
-            63..122 'if tru...     }': &[i32]
-            66..70 'true': bool
-            71..96 '{     ...     }': &[i32]
-            81..84 'foo': fn foo<i32>(&[i32]) -> &[i32]
-            81..90 'foo(&[1])': &[i32]
-            85..89 '&[1]': &[i32; 1]
-            86..89 '[1]': [i32; 1]
-            87..88 '1': i32
-            102..122 '{     ...     }': &[i32; 1]
-            112..116 '&[1]': &[i32; 1]
-            113..116 '[1]': [i32; 1]
-            114..115 '1': i32
-        "#]],
     );
 }
 
 #[test]
-fn infer_if_else_coerce() {
-    check_infer(
+fn if_else_coerce() {
+    check_no_mismatches(
         r#"
 //- minicore: coerce_unsized
-fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn foo<T>(x: &[T]) -> &[T] { x }
 fn test() {
     let x = if true {
         &[1]
@@ -223,35 +118,15 @@ fn test() {
     };
 }
 "#,
-        expect![[r#"
-            10..11 'x': &[T]
-            27..38 '{ loop {} }': &[T]
-            29..36 'loop {}': !
-            34..36 '{}': ()
-            49..125 '{     ...  }; }': ()
-            59..60 'x': &[i32]
-            63..122 'if tru...     }': &[i32]
-            66..70 'true': bool
-            71..91 '{     ...     }': &[i32; 1]
-            81..85 '&[1]': &[i32; 1]
-            82..85 '[1]': [i32; 1]
-            83..84 '1': i32
-            97..122 '{     ...     }': &[i32]
-            107..110 'foo': fn foo<i32>(&[i32]) -> &[i32]
-            107..116 'foo(&[1])': &[i32]
-            111..115 '&[1]': &[i32; 1]
-            112..115 '[1]': [i32; 1]
-            113..114 '1': i32
-        "#]],
     )
 }
 
 #[test]
-fn infer_match_first_coerce() {
-    check_infer(
+fn match_first_coerce() {
+    check_no_mismatches(
         r#"
-//- minicore: unsize
-fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
+fn foo<T>(x: &[T]) -> &[T] { x }
 fn test(i: i32) {
     let x = match i {
         2 => foo(&[2]),
@@ -260,39 +135,12 @@ fn test(i: i32) {
     };
 }
 "#,
-        expect![[r#"
-            10..11 'x': &[T]
-            27..38 '{ loop {} }': &[T]
-            29..36 'loop {}': !
-            34..36 '{}': ()
-            47..48 'i': i32
-            55..149 '{     ...  }; }': ()
-            65..66 'x': &[i32]
-            69..146 'match ...     }': &[i32]
-            75..76 'i': i32
-            87..88 '2': i32
-            87..88 '2': i32
-            92..95 'foo': fn foo<i32>(&[i32]) -> &[i32]
-            92..101 'foo(&[2])': &[i32]
-            96..100 '&[2]': &[i32; 1]
-            97..100 '[2]': [i32; 1]
-            98..99 '2': i32
-            111..112 '1': i32
-            111..112 '1': i32
-            116..120 '&[1]': &[i32; 1]
-            117..120 '[1]': [i32; 1]
-            118..119 '1': i32
-            130..131 '_': i32
-            135..139 '&[3]': &[i32; 1]
-            136..139 '[3]': [i32; 1]
-            137..138 '3': i32
-        "#]],
     );
 }
 
 #[test]
-fn infer_match_second_coerce() {
-    check_infer(
+fn match_second_coerce() {
+    check_no_mismatches(
         r#"
 //- minicore: coerce_unsized
 fn foo<T>(x: &[T]) -> &[T] { loop {} }
@@ -304,33 +152,6 @@ fn test(i: i32) {
     };
 }
 "#,
-        expect![[r#"
-            10..11 'x': &[T]
-            27..38 '{ loop {} }': &[T]
-            29..36 'loop {}': !
-            34..36 '{}': ()
-            47..48 'i': i32
-            55..149 '{     ...  }; }': ()
-            65..66 'x': &[i32]
-            69..146 'match ...     }': &[i32]
-            75..76 'i': i32
-            87..88 '1': i32
-            87..88 '1': i32
-            92..96 '&[1]': &[i32; 1]
-            93..96 '[1]': [i32; 1]
-            94..95 '1': i32
-            106..107 '2': i32
-            106..107 '2': i32
-            111..114 'foo': fn foo<i32>(&[i32]) -> &[i32]
-            111..120 'foo(&[2])': &[i32]
-            115..119 '&[2]': &[i32; 1]
-            116..119 '[2]': [i32; 1]
-            117..118 '2': i32
-            130..131 '_': i32
-            135..139 '&[3]': &[i32; 1]
-            136..139 '[3]': [i32; 1]
-            137..138 '3': i32
-        "#]],
     );
 }
 
@@ -338,94 +159,52 @@ fn test(i: i32) {
 fn coerce_merge_one_by_one1() {
     cov_mark::check!(coerce_merge_fail_fallback);
 
-    check_infer(
+    check(
         r"
-        fn test() {
-            let t = &mut 1;
-            let x = match 1 {
-                1 => t as *mut i32,
-                2 => t as &i32,
-                _ => t as *const i32,
-            };
-        }
+fn test() {
+    let t = &mut 1;
+    let x = match 1 {
+        1 => t as *mut i32,
+        2 => t as &i32,
+           //^^^^^^^^^ expected *mut i32, got &i32
+        _ => t as *const i32,
+    };
+    x;
+  //^ type: *const i32
+}
         ",
-        expect![[r"
-            10..144 '{     ...  }; }': ()
-            20..21 't': &mut i32
-            24..30 '&mut 1': &mut i32
-            29..30 '1': i32
-            40..41 'x': *const i32
-            44..141 'match ...     }': *const i32
-            50..51 '1': i32
-            62..63 '1': i32
-            62..63 '1': i32
-            67..68 't': &mut i32
-            67..80 't as *mut i32': *mut i32
-            90..91 '2': i32
-            90..91 '2': i32
-            95..96 't': &mut i32
-            95..104 't as &i32': &i32
-            114..115 '_': i32
-            119..120 't': &mut i32
-            119..134 't as *const i32': *const i32
-    "]],
     );
 }
 
 #[test]
 fn return_coerce_unknown() {
-    check_infer_with_mismatches(
+    check_types(
         r"
-        fn foo() -> u32 {
-            return unknown;
-        }
+fn foo() -> u32 {
+    return unknown;
+         //^^^^^^^ u32
+}
         ",
-        expect![[r"
-            16..39 '{     ...own; }': u32
-            22..36 'return unknown': !
-            29..36 'unknown': u32
-        "]],
     );
 }
 
 #[test]
 fn coerce_autoderef() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r"
-        struct Foo;
-        fn takes_ref_foo(x: &Foo) {}
-        fn test() {
-            takes_ref_foo(&Foo);
-            takes_ref_foo(&&Foo);
-            takes_ref_foo(&&&Foo);
-        }
-        ",
-        expect![[r"
-            29..30 'x': &Foo
-            38..40 '{}': ()
-            51..132 '{     ...oo); }': ()
-            57..70 'takes_ref_foo': fn takes_ref_foo(&Foo)
-            57..76 'takes_...(&Foo)': ()
-            71..75 '&Foo': &Foo
-            72..75 'Foo': Foo
-            82..95 'takes_ref_foo': fn takes_ref_foo(&Foo)
-            82..102 'takes_...&&Foo)': ()
-            96..101 '&&Foo': &&Foo
-            97..101 '&Foo': &Foo
-            98..101 'Foo': Foo
-            108..121 'takes_ref_foo': fn takes_ref_foo(&Foo)
-            108..129 'takes_...&&Foo)': ()
-            122..128 '&&&Foo': &&&Foo
-            123..128 '&&Foo': &&Foo
-            124..128 '&Foo': &Foo
-            125..128 'Foo': Foo
-        "]],
+struct Foo;
+fn takes_ref_foo(x: &Foo) {}
+fn test() {
+    takes_ref_foo(&Foo);
+    takes_ref_foo(&&Foo);
+    takes_ref_foo(&&&Foo);
+}",
     );
 }
 
 #[test]
 fn coerce_autoderef_generic() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r#"
 struct Foo;
 fn takes_ref<T>(x: &T) -> T { *x }
@@ -435,34 +214,12 @@ fn test() {
     takes_ref(&&&Foo);
 }
 "#,
-        expect![[r"
-            28..29 'x': &T
-            40..46 '{ *x }': T
-            42..44 '*x': T
-            43..44 'x': &T
-            57..126 '{     ...oo); }': ()
-            63..72 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
-            63..78 'takes_ref(&Foo)': Foo
-            73..77 '&Foo': &Foo
-            74..77 'Foo': Foo
-            84..93 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
-            84..100 'takes_...&&Foo)': &Foo
-            94..99 '&&Foo': &&Foo
-            95..99 '&Foo': &Foo
-            96..99 'Foo': Foo
-            106..115 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
-            106..123 'takes_...&&Foo)': &&Foo
-            116..122 '&&&Foo': &&&Foo
-            117..122 '&&Foo': &&Foo
-            118..122 '&Foo': &Foo
-            119..122 'Foo': Foo
-        "]],
     );
 }
 
 #[test]
 fn coerce_autoderef_block() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r#"
 //- minicore: deref
 struct String {}
@@ -473,71 +230,32 @@ fn test() {
     takes_ref_str(&{ returns_string() });
 }
 "#,
-        expect![[r#"
-            90..91 'x': &str
-            99..101 '{}': ()
-            132..143 '{ loop {} }': String
-            134..141 'loop {}': !
-            139..141 '{}': ()
-            154..199 '{     ... }); }': ()
-            160..173 'takes_ref_str': fn takes_ref_str(&str)
-            160..196 'takes_...g() })': ()
-            174..195 '&{ ret...ng() }': &String
-            175..195 '{ retu...ng() }': String
-            177..191 'returns_string': fn returns_string() -> String
-            177..193 'return...ring()': String
-        "#]],
     );
 }
 
 #[test]
 fn closure_return_coerce() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r"
-        fn foo() {
-            let x = || {
-                if true {
-                    return &1u32;
-                }
-                &&1u32
-            };
+fn foo() {
+    let x = || {
+        if true {
+            return &1u32;
         }
-        ",
-        expect![[r"
-            9..105 '{     ...  }; }': ()
-            19..20 'x': || -> &u32
-            23..102 '|| {  ...     }': || -> &u32
-            26..102 '{     ...     }': &u32
-            36..81 'if tru...     }': ()
-            39..43 'true': bool
-            44..81 '{     ...     }': ()
-            58..70 'return &1u32': !
-            65..70 '&1u32': &u32
-            66..70 '1u32': u32
-            90..96 '&&1u32': &&u32
-            91..96 '&1u32': &u32
-            92..96 '1u32': u32
-        "]],
+        &&1u32
+    };
+}",
     );
 }
 
 #[test]
 fn coerce_fn_item_to_fn_ptr() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r"
-        fn foo(x: u32) -> isize { 1 }
-        fn test() {
-            let f: fn(u32) -> isize = foo;
-        }
-        ",
-        expect![[r"
-            7..8 'x': u32
-            24..29 '{ 1 }': isize
-            26..27 '1': isize
-            40..78 '{     ...foo; }': ()
-            50..51 'f': fn(u32) -> isize
-            72..75 'foo': fn foo(u32) -> isize
-        "]],
+fn foo(x: u32) -> isize { 1 }
+fn test() {
+    let f: fn(u32) -> isize = foo;
+}",
     );
 }
 
@@ -545,110 +263,62 @@ fn coerce_fn_item_to_fn_ptr() {
 fn coerce_fn_items_in_match_arms() {
     cov_mark::check!(coerce_fn_reification);
 
-    check_infer_with_mismatches(
+    check_types(
         r"
-        fn foo1(x: u32) -> isize { 1 }
-        fn foo2(x: u32) -> isize { 2 }
-        fn foo3(x: u32) -> isize { 3 }
-        fn test() {
-            let x = match 1 {
-                1 => foo1,
-                2 => foo2,
-                _ => foo3,
-            };
-        }
-        ",
-        expect![[r"
-            8..9 'x': u32
-            25..30 '{ 1 }': isize
-            27..28 '1': isize
-            39..40 'x': u32
-            56..61 '{ 2 }': isize
-            58..59 '2': isize
-            70..71 'x': u32
-            87..92 '{ 3 }': isize
-            89..90 '3': isize
-            103..192 '{     ...  }; }': ()
-            113..114 'x': fn(u32) -> isize
-            117..189 'match ...     }': fn(u32) -> isize
-            123..124 '1': i32
-            135..136 '1': i32
-            135..136 '1': i32
-            140..144 'foo1': fn foo1(u32) -> isize
-            154..155 '2': i32
-            154..155 '2': i32
-            159..163 'foo2': fn foo2(u32) -> isize
-            173..174 '_': i32
-            178..182 'foo3': fn foo3(u32) -> isize
-        "]],
+fn foo1(x: u32) -> isize { 1 }
+fn foo2(x: u32) -> isize { 2 }
+fn foo3(x: u32) -> isize { 3 }
+fn test() {
+    let x = match 1 {
+        1 => foo1,
+        2 => foo2,
+        _ => foo3,
+    };
+    x;
+  //^ fn(u32) -> isize
+}",
     );
 }
 
 #[test]
 fn coerce_closure_to_fn_ptr() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r"
-        fn test() {
-            let f: fn(u32) -> isize = |x| { 1 };
-        }
-        ",
-        expect![[r"
-            10..54 '{     ...1 }; }': ()
-            20..21 'f': fn(u32) -> isize
-            42..51 '|x| { 1 }': |u32| -> isize
-            43..44 'x': u32
-            46..51 '{ 1 }': isize
-            48..49 '1': isize
-        "]],
+fn test() {
+    let f: fn(u32) -> isize = |x| { 1 };
+}",
     );
 }
 
 #[test]
 fn coerce_placeholder_ref() {
     // placeholders should unify, even behind references
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r"
-        struct S<T> { t: T }
-        impl<TT> S<TT> {
-            fn get(&self) -> &TT {
-                &self.t
-            }
-        }
-        ",
-        expect![[r"
-            50..54 'self': &S<TT>
-            63..86 '{     ...     }': &TT
-            73..80 '&self.t': &TT
-            74..78 'self': &S<TT>
-            74..80 'self.t': TT
-        "]],
+struct S<T> { t: T }
+impl<TT> S<TT> {
+    fn get(&self) -> &TT {
+        &self.t
+    }
+}",
     );
 }
 
 #[test]
 fn coerce_unsize_array() {
-    check_infer_with_mismatches(
+    check_types(
         r#"
 //- minicore: coerce_unsized
 fn test() {
     let f: &[usize] = &[1, 2, 3];
-}
-        "#,
-        expect![[r#"
-            10..47 '{     ... 3]; }': ()
-            20..21 'f': &[usize]
-            34..44 '&[1, 2, 3]': &[usize; 3]
-            35..44 '[1, 2, 3]': [usize; 3]
-            36..37 '1': usize
-            39..40 '2': usize
-            42..43 '3': usize
-        "#]],
+                      //^ usize
+}"#,
     );
 }
 
 #[test]
 fn coerce_unsize_trait_object_simple() {
-    check_infer_with_mismatches(
+    check_types(
         r#"
 //- minicore: coerce_unsized
 trait Foo<T, U> {}
@@ -662,88 +332,18 @@ impl<T, X> Baz<T, X> for S<T, X> {}
 
 fn test() {
     let obj: &dyn Baz<i8, i16> = &S;
+                                //^ S<i8, i16>
     let obj: &dyn Bar<_, i8, i16> = &S;
+                                   //^ S<i8, i16>
     let obj: &dyn Foo<i8, _> = &S;
-}
-"#,
-        expect![[r#"
-            236..351 '{     ... &S; }': ()
-            246..249 'obj': &dyn Baz<i8, i16>
-            271..273 '&S': &S<i8, i16>
-            272..273 'S': S<i8, i16>
-            283..286 'obj': &dyn Bar<usize, i8, i16>
-            311..313 '&S': &S<i8, i16>
-            312..313 'S': S<i8, i16>
-            323..326 'obj': &dyn Foo<i8, usize>
-            346..348 '&S': &S<i8, {unknown}>
-            347..348 'S': S<i8, {unknown}>
-        "#]],
-    );
-}
-
-#[test]
-fn coerce_unsize_trait_object_to_trait_object() {
-    // FIXME: The rust reference says this should be possible, but rustc doesn't
-    // implement it. We used to support it, but Chalk doesn't. Here's the
-    // correct expect:
-    //
-    //     424..609 '{     ...bj2; }': ()
-    //     434..437 'obj': &dyn Baz<i8, i16>
-    //     459..461 '&S': &S<i8, i16>
-    //     460..461 'S': S<i8, i16>
-    //     471..474 'obj': &dyn Bar<usize, i8, i16>
-    //     496..499 'obj': &dyn Baz<i8, i16>
-    //     509..512 'obj': &dyn Foo<i8, usize>
-    //     531..534 'obj': &dyn Bar<usize, i8, i16>
-    //     544..548 'obj2': &dyn Baz<i8, i16>
-    //     570..572 '&S': &S<i8, i16>
-    //     571..572 'S': S<i8, i16>
-    //     582..583 '_': &dyn Foo<i8, usize>
-    //     602..606 'obj2': &dyn Baz<i8, i16>
-    check_infer_with_mismatches(
-        r#"
-//- minicore: coerce_unsized
-trait Foo<T, U> {}
-trait Bar<U, T, X>: Foo<T, U> {}
-trait Baz<T, X>: Bar<usize, T, X> {}
-
-struct S<T, X>;
-impl<T, X> Foo<T, usize> for S<T, X> {}
-impl<T, X> Bar<usize, T, X> for S<T, X> {}
-impl<T, X> Baz<T, X> for S<T, X> {}
-
-fn test() {
-    let obj: &dyn Baz<i8, i16> = &S;
-    let obj: &dyn Bar<_, _, _> = obj;
-    let obj: &dyn Foo<_, _> = obj;
-    let obj2: &dyn Baz<i8, i16> = &S;
-    let _: &dyn Foo<_, _> = obj2;
-}
-"#,
-        expect![[r#"
-            236..421 '{     ...bj2; }': ()
-            246..249 'obj': &dyn Baz<i8, i16>
-            271..273 '&S': &S<i8, i16>
-            272..273 'S': S<i8, i16>
-            283..286 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}>
-            308..311 'obj': &dyn Baz<i8, i16>
-            321..324 'obj': &dyn Foo<{unknown}, {unknown}>
-            343..346 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}>
-            356..360 'obj2': &dyn Baz<i8, i16>
-            382..384 '&S': &S<i8, i16>
-            383..384 'S': S<i8, i16>
-            394..395 '_': &dyn Foo<{unknown}, {unknown}>
-            414..418 'obj2': &dyn Baz<i8, i16>
-            308..311: expected &dyn Bar<{unknown}, {unknown}, {unknown}>, got &dyn Baz<i8, i16>
-            343..346: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Bar<{unknown}, {unknown}, {unknown}>
-            414..418: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Baz<i8, i16>
-        "#]],
+                              //^ S<i8, {unknown}>
+}"#,
     );
 }
 
 #[test]
 fn coerce_unsize_super_trait_cycle() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
         r#"
 //- minicore: coerce_unsized
 trait A {}
@@ -762,22 +362,13 @@ fn test() {
     let obj: &dyn A = &S;
 }
 "#,
-        expect![[r#"
-            140..195 '{     ... &S; }': ()
-            150..153 'obj': &dyn D
-            164..166 '&S': &S
-            165..166 'S': S
-            176..179 'obj': &dyn A
-            190..192 '&S': &S
-            191..192 'S': S
-        "#]],
     );
 }
 
 #[test]
 fn coerce_unsize_generic() {
     // FIXME: fix the type mismatches here
-    check_infer_with_mismatches(
+    check(
         r#"
 //- minicore: coerce_unsized
 struct Foo<T> { t: T };
@@ -785,73 +376,47 @@ struct Bar<T>(Foo<T>);
 
 fn test() {
     let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
+                                   //^^^^^^^^^ expected [usize], got [usize; 3]
     let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
+                         //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &Bar<[usize]>, got &Bar<[i32; 3]>
 }
 "#,
-        expect![[r#"
-            58..166 '{     ... }); }': ()
-            68..69 '_': &Foo<[usize]>
-            87..108 '&Foo {..., 3] }': &Foo<[usize]>
-            88..108 'Foo { ..., 3] }': Foo<[usize]>
-            97..106 '[1, 2, 3]': [usize; 3]
-            98..99 '1': usize
-            101..102 '2': usize
-            104..105 '3': usize
-            118..119 '_': &Bar<[usize]>
-            137..163 '&Bar(F... 3] })': &Bar<[i32; 3]>
-            138..141 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
-            138..163 'Bar(Fo... 3] })': Bar<[i32; 3]>
-            142..162 'Foo { ..., 3] }': Foo<[i32; 3]>
-            151..160 '[1, 2, 3]': [i32; 3]
-            152..153 '1': i32
-            155..156 '2': i32
-            158..159 '3': i32
-            97..106: expected [usize], got [usize; 3]
-            137..163: expected &Bar<[usize]>, got &Bar<[i32; 3]>
-        "#]],
     );
 }
 
 #[test]
 fn coerce_unsize_apit() {
     // FIXME: #8984
-    check_infer_with_mismatches(
+    check(
         r#"
 //- minicore: coerce_unsized
 trait Foo {}
 
 fn test(f: impl Foo) {
     let _: &dyn Foo = &f;
+                    //^^ expected &dyn Foo, got &impl Foo
 }
         "#,
-        expect![[r#"
-            22..23 'f': impl Foo
-            35..64 '{     ... &f; }': ()
-            45..46 '_': &dyn Foo
-            59..61 '&f': &impl Foo
-            60..61 'f': impl Foo
-            59..61: expected &dyn Foo, got &impl Foo
-        "#]],
     );
 }
 
 #[test]
-fn infer_two_closures_lub() {
+fn two_closures_lub() {
     check_types(
         r#"
 fn foo(c: i32) {
     let add = |a: i32, b: i32| a + b;
     let sub = |a, b| a - b;
-            //^ |i32, i32| -> i32
+            //^^^^^^^^^^^^ |i32, i32| -> i32
     if c > 42 { add } else { sub };
-  //^ fn(i32, i32) -> i32
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ fn(i32, i32) -> i32
 }
         "#,
     )
 }
 
 #[test]
-fn infer_match_diverging_branch_1() {
+fn match_diverging_branch_1() {
     check_types(
         r#"
 enum Result<T> { Ok(T), Err }
@@ -870,7 +435,7 @@ fn test() -> i32 {
 }
 
 #[test]
-fn infer_match_diverging_branch_2() {
+fn match_diverging_branch_2() {
     // same as 1 except for order of branches
     check_types(
         r#"
diff --git a/crates/hir_ty/src/tests/display_source_code.rs b/crates/hir_ty/src/tests/display_source_code.rs
index 3d29021aa..058cd02d7 100644
--- a/crates/hir_ty/src/tests/display_source_code.rs
+++ b/crates/hir_ty/src/tests/display_source_code.rs
@@ -10,8 +10,8 @@ mod foo {
 
 fn bar() {
     let foo: foo::Foo = foo::Foo;
-    foo
-}  //^ foo::Foo
+    foo;
+} //^^^ foo::Foo
 
 "#,
     );
@@ -25,7 +25,7 @@ struct Foo<T = u8> { t: T }
 fn main() {
     let foo = Foo { t: 5u8 };
     foo;
-}  //^ Foo
+} //^^^ Foo
 "#,
     );
 
@@ -35,7 +35,7 @@ struct Foo<K, T = u8> { k: K, t: T }
 fn main() {
     let foo = Foo { k: 400, t: 5u8 };
     foo;
-}   //^ Foo<i32>
+} //^^^ Foo<i32>
 "#,
     );
 }
@@ -50,7 +50,7 @@ fn foo() -> *const (impl Unpin + Sized) { loop {} }
 fn main() {
     let foo = foo();
     foo;
-}   //^ *const (impl Unpin + Sized)
+} //^^^ *const (impl Unpin + Sized)
 "#,
     );
 }
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index d14103aab..2cf41e49e 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -435,11 +435,11 @@ fn processes_impls_generated_by_macros() {
 macro_rules! m {
     ($ident:ident) => (impl Trait for $ident {})
 }
-trait Trait { fn foo(self) -> u128 {} }
+trait Trait { fn foo(self) -> u128 { 0 } }
 struct S;
 m!(S);
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
     );
 }
@@ -457,7 +457,7 @@ impl S {
 }
 
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
     );
 }
@@ -479,7 +479,7 @@ impl S {
 }
 
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
     );
 }
@@ -743,7 +743,7 @@ include!("foo.rs");
 
 fn main() {
     bar();
-}     //^ u32
+} //^^^^^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
@@ -781,7 +781,7 @@ include!("f/foo.rs");
 
 fn main() {
     bar::bar();
-}          //^ u32
+} //^^^^^^^^^^ u32
 
 //- /f/foo.rs
 pub mod bar;
@@ -853,7 +853,7 @@ include!("foo.rs");
 
 fn main() {
     RegisterBlock { };
-                  //^ RegisterBlock
+  //^^^^^^^^^^^^^^^^^ RegisterBlock
 }
     "#;
     let fixture = format!("{}\n//- /foo.rs\n{}", fixture, data);
@@ -879,7 +879,7 @@ include!(concat!("f", "oo.rs"));
 
 fn main() {
     bar();
-}     //^ u32
+} //^^^^^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
@@ -905,7 +905,7 @@ include!(concat!(env!("OUT_DIR"), "/foo.rs"));
 
 fn main() {
     bar();
-}     //^ {unknown}
+} //^^^^^ {unknown}
 
 //- /foo.rs
 fn bar() -> u32 {0}
@@ -923,7 +923,7 @@ macro_rules! include {() => {}}
 include!("main.rs");
 
 fn main() {
-            0
+    0;
 } //^ i32
 "#,
     );
@@ -979,7 +979,7 @@ fn infer_derive_clone_simple() {
 struct S;
 fn test() {
     S.clone();
-}         //^ S
+} //^^^^^^^^^ S
 
 //- /lib.rs crate:core
 pub mod prelude {
@@ -1028,7 +1028,7 @@ pub struct S;
 use core::S;
 fn test() {
     S.clone();
-}         //^ S
+} //^^^^^^^^^ S
 "#,
     );
 }
@@ -1044,7 +1044,8 @@ struct S;
 struct Wrapper<T>(T);
 struct NonClone;
 fn test() {
-    (Wrapper(S).clone(), Wrapper(NonClone).clone());
+    let x = (Wrapper(S).clone(), Wrapper(NonClone).clone());
+    x;
   //^ (Wrapper<S>, {unknown})
 }
 
@@ -1079,7 +1080,7 @@ struct S{}
 
 fn test() {
     S{};
-}   //^ S
+} //^^^ S
 "#,
     );
 }
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index d9b5ee9cf..3f7a37295 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -257,7 +257,7 @@ fn test() {
 mod foo {
     struct S;
     impl S {
-        fn thing() -> i128 {}
+        fn thing() -> i128 { 0 }
     }
 }
 "#,
@@ -267,164 +267,128 @@ mod foo {
 #[test]
 fn infer_trait_method_simple() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    check_infer(
+    check_types(
         r#"
-        trait Trait1 {
-            fn method(&self) -> u32;
-        }
-        struct S1;
-        impl Trait1 for S1 {}
-        trait Trait2 {
-            fn method(&self) -> i128;
-        }
-        struct S2;
-        impl Trait2 for S2 {}
-        fn test() {
-            S1.method(); // -> u32
-            S2.method(); // -> i128
-        }
+trait Trait1 {
+    fn method(&self) -> u32;
+}
+struct S1;
+impl Trait1 for S1 {}
+trait Trait2 {
+    fn method(&self) -> i128;
+}
+struct S2;
+impl Trait2 for S2 {}
+fn test() {
+    S1.method();
+  //^^^^^^^^^^^ u32
+    S2.method(); // -> i128
+  //^^^^^^^^^^^ i128
+}
         "#,
-        expect![[r#"
-            30..34 'self': &Self
-            109..113 'self': &Self
-            169..227 '{     ...i128 }': ()
-            175..177 'S1': S1
-            175..186 'S1.method()': u32
-            202..204 'S2': S2
-            202..213 'S2.method()': i128
-        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_scoped() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    check_infer(
+    check_types(
         r#"
-        struct S;
-        mod foo {
-            pub trait Trait1 {
-                fn method(&self) -> u32;
-            }
-            impl Trait1 for super::S {}
-        }
-        mod bar {
-            pub trait Trait2 {
-                fn method(&self) -> i128;
-            }
-            impl Trait2 for super::S {}
-        }
+struct S;
+mod foo {
+    pub trait Trait1 {
+        fn method(&self) -> u32;
+    }
+    impl Trait1 for super::S {}
+}
+mod bar {
+    pub trait Trait2 {
+        fn method(&self) -> i128;
+    }
+    impl Trait2 for super::S {}
+}
 
-        mod foo_test {
-            use super::S;
-            use super::foo::Trait1;
-            fn test() {
-                S.method(); // -> u32
-            }
-        }
+mod foo_test {
+    use super::S;
+    use super::foo::Trait1;
+    fn test() {
+        S.method();
+      //^^^^^^^^^^ u32
+    }
+}
 
-        mod bar_test {
-            use super::S;
-            use super::bar::Trait2;
-            fn test() {
-                S.method(); // -> i128
-            }
-        }
+mod bar_test {
+    use super::S;
+    use super::bar::Trait2;
+    fn test() {
+        S.method();
+      //^^^^^^^^^^ i128
+    }
+}
         "#,
-        expect![[r#"
-            62..66 'self': &Self
-            168..172 'self': &Self
-            299..336 '{     ...     }': ()
-            309..310 'S': S
-            309..319 'S.method()': u32
-            415..453 '{     ...     }': ()
-            425..426 'S': S
-            425..435 'S.method()': i128
-        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_1() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    check_infer(
+    check_types(
         r#"
-        trait Trait<T> {
-            fn method(&self) -> T;
-        }
-        struct S;
-        impl Trait<u32> for S {}
-        fn test() {
-            S.method();
-        }
+trait Trait<T> {
+    fn method(&self) -> T;
+}
+struct S;
+impl Trait<u32> for S {}
+fn test() {
+    S.method();
+  //^^^^^^^^^^ u32
+}
         "#,
-        expect![[r#"
-            32..36 'self': &Self
-            91..110 '{     ...d(); }': ()
-            97..98 'S': S
-            97..107 'S.method()': u32
-        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_more_params() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    check_infer(
+    check_types(
         r#"
-        trait Trait<T1, T2, T3> {
-            fn method1(&self) -> (T1, T2, T3);
-            fn method2(&self) -> (T3, T2, T1);
-        }
-        struct S1;
-        impl Trait<u8, u16, u32> for S1 {}
-        struct S2;
-        impl<T> Trait<i8, i16, T> for S2 {}
-        fn test() {
-            S1.method1(); // u8, u16, u32
-            S1.method2(); // u32, u16, u8
-            S2.method1(); // i8, i16, {unknown}
-            S2.method2(); // {unknown}, i16, i8
-        }
+trait Trait<T1, T2, T3> {
+    fn method1(&self) -> (T1, T2, T3);
+    fn method2(&self) -> (T3, T2, T1);
+}
+struct S1;
+impl Trait<u8, u16, u32> for S1 {}
+struct S2;
+impl<T> Trait<i8, i16, T> for S2 {}
+fn test() {
+    S1.method1();
+  //^^^^^^^^^^^^ (u8, u16, u32)
+    S1.method2();
+  //^^^^^^^^^^^^ (u32, u16, u8)
+    S2.method1();
+  //^^^^^^^^^^^^ (i8, i16, {unknown})
+    S2.method2();
+  //^^^^^^^^^^^^ ({unknown}, i16, i8)
+}
         "#,
-        expect![[r#"
-            42..46 'self': &Self
-            81..85 'self': &Self
-            209..360 '{     ..., i8 }': ()
-            215..217 'S1': S1
-            215..227 'S1.method1()': (u8, u16, u32)
-            249..251 'S1': S1
-            249..261 'S1.method2()': (u32, u16, u8)
-            283..285 'S2': S2
-            283..295 'S2.method1()': (i8, i16, {unknown})
-            323..325 'S2': S2
-            323..335 'S2.method2()': ({unknown}, i16, i8)
-        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_2() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    check_infer(
+    check_types(
         r#"
-        trait Trait<T> {
-            fn method(&self) -> T;
-        }
-        struct S<T>(T);
-        impl<U> Trait<U> for S<U> {}
-        fn test() {
-            S(1u32).method();
-        }
+trait Trait<T> {
+    fn method(&self) -> T;
+}
+struct S<T>(T);
+impl<U> Trait<U> for S<U> {}
+fn test() {
+    S(1u32).method();
+  //^^^^^^^^^^^^^^^^ u32
+}
         "#,
-        expect![[r#"
-            32..36 'self': &Self
-            101..126 '{     ...d(); }': ()
-            107..108 'S': S<u32>(u32) -> S<u32>
-            107..114 'S(1u32)': S<u32>
-            107..123 'S(1u32...thod()': u32
-            109..113 '1u32': u32
-        "#]],
     );
 }
 
@@ -685,10 +649,10 @@ fn method_resolution_unify_impl_self_type() {
     check_types(
         r#"
 struct S<T>;
-impl S<u32> { fn foo(&self) -> u8 {} }
-impl S<i32> { fn foo(&self) -> i8 {} }
+impl S<u32> { fn foo(&self) -> u8 { 0 } }
+impl S<i32> { fn foo(&self) -> i8 { 0 } }
 fn test() { (S::<u32>.foo(), S::<i32>.foo()); }
-          //^ (u8, i8)
+          //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (u8, i8)
 "#,
     );
 }
@@ -702,7 +666,7 @@ struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
     );
 }
@@ -716,7 +680,7 @@ struct S;
 impl Clone for S {}
 impl Clone for &S {}
 fn test() { (S.clone(), (&S).clone(), (&&S).clone()); }
-          //^ (S, S, &S)
+          //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (S, S, &S)
 "#,
     );
 }
@@ -730,7 +694,7 @@ struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
 fn test() { (&S).foo(); }
-                   //^ u128
+          //^^^^^^^^^^ u128
 "#,
     );
 }
@@ -744,7 +708,7 @@ struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
 fn test() { S.foo(); }
-                //^ i8
+          //^^^^^^^ i8
 "#,
     );
 }
@@ -758,7 +722,7 @@ struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
 fn test() { S.foo(); }
-                //^ i8
+          //^^^^^^^ i8
 "#,
     );
 }
@@ -771,7 +735,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S { fn foo(self) -> u128 { 0 } }
 fn test() { (&S).foo(); }
-                   //^ u128
+          //^^^^^^^^^^ u128
 "#,
     );
 }
@@ -784,7 +748,7 @@ fn method_resolution_unsize_array() {
 fn test() {
     let a = [1, 2, 3];
     a.len();
-}       //^ usize
+} //^^^^^^^ usize
 "#,
     );
 }
@@ -799,7 +763,7 @@ impl Clone for S {}
 
 fn test() {
     S.clone();
-          //^ S
+  //^^^^^^^^^ S
 }
 
 //- /lib.rs crate:core
@@ -823,7 +787,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: UnknownTrait {}
 fn test() { (&S).foo(); }
-                   //^ u128
+          //^^^^^^^^^^ u128
 "#,
     );
 }
@@ -841,7 +805,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: Clone {}
 fn test() { (&S).foo(); }
-                   //^ {unknown}
+          //^^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -856,7 +820,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T: Clone> Trait for T {}
 fn test() { (&S).foo(); }
-                   //^ {unknown}
+          //^^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -871,7 +835,7 @@ struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
     );
 }
@@ -887,7 +851,7 @@ struct S2;
 impl From<S2> for S1 {}
 impl<T, U> Into<U> for T where U: From<T> {}
 fn test() { S2.into(); }
-                  //^ {unknown}
+          //^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -903,7 +867,7 @@ struct S2;
 impl From<S2> for S1 {}
 impl<T, U: From<T>> Into<U> for T {}
 fn test() { S2.into(); }
-                  //^ {unknown}
+          //^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -933,7 +897,7 @@ fn main() {
     let a = Wrapper::<Foo<f32>>::new(1.0);
     let b = Wrapper::<Bar<f32>>::new(1.0);
     (a, b);
-  //^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)
+  //^^^^^^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)
 }
 "#,
     );
@@ -947,7 +911,7 @@ fn method_resolution_encountering_fn_type() {
 fn foo() {}
 trait FnOnce { fn call(self); }
 fn test() { foo.call(); }
-                   //^ {unknown}
+          //^^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -1013,7 +977,7 @@ where
     Wrapper<T>: a::Foo,
 {
     t.foo();
-}       //^ {unknown}
+} //^^^^^^^ {unknown}
 "#,
     );
 }
@@ -1030,7 +994,7 @@ impl A<i32> {
 
 fn main() {
     A::from(3);
-}          //^ A<i32>
+} //^^^^^^^^^^ A<i32>
 "#,
     );
 }
@@ -1058,7 +1022,7 @@ trait FnX {}
 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
 
 fn test() { (S {}).method(); }
-                        //^ ()
+          //^^^^^^^^^^^^^^^ ()
 "#,
     );
 }
@@ -1143,8 +1107,8 @@ impl<T> Slice<T> {
 
 fn main() {
     let foo: Slice<u32>;
-    (foo.into_vec()); // we don't actually support arbitrary self types, but we shouldn't crash at least
-} //^ {unknown}
+    foo.into_vec(); // we shouldn't crash on this at least
+} //^^^^^^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -1165,7 +1129,7 @@ impl dyn Foo + '_ {
 fn main() {
     let f = &42u32 as &dyn Foo;
     f.dyn_foo();
-  // ^u32
+ // ^^^^^^^^^^^ u32
 }
 "#,
     );
@@ -1376,11 +1340,11 @@ pub trait IntoIterator {
 
 impl<T> IntoIterator for [T; 1] {
     type Out = T;
-    fn into_iter(self) -> Self::Out {}
+    fn into_iter(self) -> Self::Out { loop {} }
 }
 impl<'a, T> IntoIterator for &'a [T] {
     type Out = &'a T;
-    fn into_iter(self) -> Self::Out {}
+    fn into_iter(self) -> Self::Out { loop {} }
 }
     "#,
     );
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 5adbe9c45..47aa30d2e 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
 
-use super::{check_infer, check_infer_with_mismatches, check_mismatches, check_types};
+use super::{check, check_infer, check_infer_with_mismatches, check_types};
 
 #[test]
 fn infer_pattern() {
@@ -518,7 +518,7 @@ fn infer_generics_in_patterns() {
 
 #[test]
 fn infer_const_pattern() {
-    check_mismatches(
+    check(
         r#"
 enum Option<T> { None }
 use Option::None;
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index 0f418ea49..8c5e8954c 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
 
-use super::{check_infer, check_types};
+use super::{check_infer, check_no_mismatches, check_types};
 
 #[test]
 fn bug_484() {
@@ -422,20 +422,20 @@ fn issue_2683_chars_impl() {
 pub struct Chars<'a> {}
 impl<'a> Iterator for Chars<'a> {
     type Item = char;
-    fn next(&mut self) -> Option<char> {}
+    fn next(&mut self) -> Option<char> { loop {} }
 }
 
 fn test() {
     let chars: Chars<'_>;
     (chars.next(), chars.nth(1));
-} //^ (Option<char>, Option<char>)
+} //^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (Option<char>, Option<char>)
 "#,
     );
 }
 
 #[test]
 fn issue_3642_bad_macro_stackover() {
-    check_types(
+    check_no_mismatches(
         r#"
 #[macro_export]
 macro_rules! match_ast {
@@ -452,7 +452,6 @@ macro_rules! match_ast {
 
 fn main() {
     let anchor = match_ast! {
-       //^ ()
         match parent {
             as => {},
             _ => return None
@@ -956,7 +955,7 @@ trait IterTrait<'a, T: 'a>: Iterator<Item = &'a T> {
 
 fn clone_iter<T>(s: Iter<T>) {
     s.inner.clone_box();
-    //^^^^^^^^^^^^^^^^^^^ ()
+  //^^^^^^^^^^^^^^^^^^^ ()
 }
 "#,
     )
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 108ff3179..b4bcc6d95 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -60,7 +60,7 @@ enum Nat { Succ(Self), Demo(Nat), Zero }
 fn test() {
     let foo: Nat = Nat::Zero;
     if let Nat::Succ(x) = foo {
-        x
+        x;
     } //^ Nat
 }
 "#,
@@ -138,7 +138,7 @@ enum Option<T> { Some(T), None }
 fn test() {
     let foo: Option<f32> = None;
     while let Option::Some(x) = foo {
-        x
+        x;
     } //^ f32
 }
 "#,
@@ -1745,7 +1745,7 @@ impl i32 { fn foo(&self) -> Foo { Foo } }
 fn main() {
     let x: i32 = i32;
     x.foo();
-        //^ Foo
+  //^^^^^^^ Foo
 }"#,
     );
 }
@@ -1763,7 +1763,7 @@ fn main() {
     fn inner() {}
     let x: i32 = i32;
     x.foo();
-        //^ Foo
+  //^^^^^^^ Foo
 }"#,
     );
 }
@@ -1781,7 +1781,7 @@ fn foo() -> &'static str { "" }
 
 fn main() {
     foo();
-      //^ &str
+  //^^^^^ &str
 }"#,
     );
 }
@@ -1799,7 +1799,7 @@ fn foo() -> &'static str { "" }
 
 fn main() {
     str::foo();
-           //^ u32
+  //^^^^^^^^^^ u32
 }"#,
     );
 }
@@ -1825,9 +1825,9 @@ mod d {
 
 fn main() {
     d::foo();
-         //^ u8
+  //^^^^^^^^ u8
     d::foo{a:0};
-           //^ u8
+  //^^^^^^^^^^^ foo
 }"#,
     );
 }
@@ -2677,7 +2677,7 @@ fn prelude_2015() {
 //- /main.rs edition:2015 crate:main deps:core
 fn f() {
     Rust;
-     //^ Rust
+  //^^^^ Rust
 }
 
 //- /core.rs crate:core
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 279a1354a..a0ddad570 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -1,6 +1,7 @@
+use cov_mark::check;
 use expect_test::expect;
 
-use super::{check_infer, check_infer_with_mismatches, check_types};
+use super::{check, check_infer, check_infer_with_mismatches, check_types};
 
 #[test]
 fn infer_await() {
@@ -285,7 +286,7 @@ mod ops {
 
 #[test]
 fn infer_from_bound_1() {
-    check_infer(
+    check_types(
         r#"
 trait Trait<T> {}
 struct S<T>(T);
@@ -293,99 +294,62 @@ impl<U> Trait<U> for S<U> {}
 fn foo<T: Trait<u32>>(t: T) {}
 fn test() {
     let s = S(unknown);
+           // ^^^^^^^ u32
     foo(s);
 }"#,
-        expect![[r#"
-            85..86 't': T
-            91..93 '{}': ()
-            104..143 '{     ...(s); }': ()
-            114..115 's': S<u32>
-            118..119 'S': S<u32>(u32) -> S<u32>
-            118..128 'S(unknown)': S<u32>
-            120..127 'unknown': u32
-            134..137 'foo': fn foo<S<u32>>(S<u32>)
-            134..140 'foo(s)': ()
-            138..139 's': S<u32>
-        "#]],
     );
 }
 
 #[test]
 fn infer_from_bound_2() {
-    check_infer(
+    check_types(
         r#"
 trait Trait<T> {}
 struct S<T>(T);
 impl<U> Trait<U> for S<U> {}
-fn foo<U, T: Trait<U>>(t: T) -> U {}
+fn foo<U, T: Trait<U>>(t: T) -> U { loop {} }
 fn test() {
     let s = S(unknown);
+           // ^^^^^^^ u32
     let x: u32 = foo(s);
 }"#,
-        expect![[r#"
-            86..87 't': T
-            97..99 '{}': ()
-            110..162 '{     ...(s); }': ()
-            120..121 's': S<u32>
-            124..125 'S': S<u32>(u32) -> S<u32>
-            124..134 'S(unknown)': S<u32>
-            126..133 'unknown': u32
-            144..145 'x': u32
-            153..156 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
-            153..159 'foo(s)': u32
-            157..158 's': S<u32>
-        "#]],
     );
 }
 
 #[test]
 fn trait_default_method_self_bound_implements_trait() {
     cov_mark::check!(trait_self_implements_self);
-    check_infer(
+    check(
         r#"
 trait Trait {
     fn foo(&self) -> i64;
-    fn bar(&self) -> {
-        let x = self.foo();
+    fn bar(&self) -> () {
+        self.foo();
+     // ^^^^^^^^^^ type: i64
     }
 }"#,
-        expect![[r#"
-            26..30 'self': &Self
-            52..56 'self': &Self
-            61..96 '{     ...     }': ()
-            75..76 'x': i64
-            79..83 'self': &Self
-            79..89 'self.foo()': i64
-        "#]],
     );
 }
 
 #[test]
 fn trait_default_method_self_bound_implements_super_trait() {
-    check_infer(
+    check(
         r#"
 trait SuperTrait {
     fn foo(&self) -> i64;
 }
 trait Trait: SuperTrait {
-    fn bar(&self) -> {
-        let x = self.foo();
+    fn bar(&self) -> () {
+        self.foo();
+     // ^^^^^^^^^^ type: i64
     }
 }"#,
-        expect![[r#"
-            31..35 'self': &Self
-            85..89 'self': &Self
-            94..129 '{     ...     }': ()
-            108..109 'x': i64
-            112..116 'self': &Self
-            112..122 'self.foo()': i64
-        "#]],
     );
 }
 
 #[test]
 fn infer_project_associated_type() {
-    check_infer(
+    check_types(
         r#"
 trait Iterable {
     type Item;
@@ -394,89 +358,62 @@ struct S;
 impl Iterable for S { type Item = u32; }
 fn test<T: Iterable>() {
     let x: <S as Iterable>::Item = 1;
-    let y: <T as Iterable>::Item = no_matter;
-    let z: T::Item = no_matter;
-    let a: <T>::Item = no_matter;
+                                // ^ u32
+    let y: <T as Iterable>::Item = u;
+                                // ^ Iterable::Item<T>
+    let z: T::Item = u;
+                  // ^ Iterable::Item<T>
+    let a: <T>::Item = u;
+                    // ^ Iterable::Item<T>
 }"#,
-        expect![[r#"
-            108..261 '{     ...ter; }': ()
-            118..119 'x': u32
-            145..146 '1': u32
-            156..157 'y': Iterable::Item<T>
-            183..192 'no_matter': Iterable::Item<T>
-            202..203 'z': Iterable::Item<T>
-            215..224 'no_matter': Iterable::Item<T>
-            234..235 'a': Iterable::Item<T>
-            249..258 'no_matter': Iterable::Item<T>
-        "#]],
     );
 }
 
 #[test]
 fn infer_return_associated_type() {
-    check_infer(
+    check_types(
         r#"
 trait Iterable {
     type Item;
 }
 struct S;
 impl Iterable for S { type Item = u32; }
-fn foo1<T: Iterable>(t: T) -> T::Item {}
-fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
-fn foo3<T: Iterable>(t: T) -> <T>::Item {}
+fn foo1<T: Iterable>(t: T) -> T::Item { loop {} }
+fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item { loop {} }
+fn foo3<T: Iterable>(t: T) -> <T>::Item { loop {} }
 fn test() {
-    let x = foo1(S);
-    let y = foo2(S);
-    let z = foo3(S);
+    foo1(S);
+ // ^^^^^^^ u32
+    foo2(S);
+ // ^^^^^^^ u32
+    foo3(S);
+ // ^^^^^^^ u32
 }"#,
-        expect![[r#"
-            106..107 't': T
-            123..125 '{}': ()
-            147..148 't': T
-            178..180 '{}': ()
-            202..203 't': T
-            221..223 '{}': ()
-            234..300 '{     ...(S); }': ()
-            244..245 'x': u32
-            248..252 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
-            248..255 'foo1(S)': u32
-            253..254 'S': S
-            265..266 'y': u32
-            269..273 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
-            269..276 'foo2(S)': u32
-            274..275 'S': S
-            286..287 'z': u32
-            290..294 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
-            290..297 'foo3(S)': u32
-            295..296 'S': S
-        "#]],
     );
 }
 
 #[test]
 fn infer_associated_type_bound() {
-    check_infer(
+    check_types(
         r#"
 trait Iterable {
     type Item;
 }
 fn test<T: Iterable<Item=u32>>() {
     let y: T::Item = unknown;
+                  // ^^^^^^^ u32
 }"#,
-        expect![[r#"
-            67..100 '{     ...own; }': ()
-            77..78 'y': u32
-            90..97 'unknown': u32
-        "#]],
     );
 }
 
 #[test]
 fn infer_const_body() {
+    // FIXME make check_types work with other bodies
     check_infer(
         r#"
 const A: u32 = 1 + 1;
-static B: u64 = { let x = 1; x };"#,
+static B: u64 = { let x = 1; x };
+"#,
         expect![[r#"
             15..16 '1': u32
             15..20 '1 + 1': u32
@@ -637,12 +574,12 @@ impl<T> core::ops::Deref for Arc<T> {
 
 struct S;
 impl S {
-    fn foo(&self) -> u128 {}
+    fn foo(&self) -> u128 { 0 }
 }
 
 fn test(s: Arc<S>) {
     (*s, s.foo());
-} //^ (S, u128)
+} //^^^^^^^^^^^^^ (S, u128)
 "#,
     );
 }
@@ -653,7 +590,7 @@ fn deref_trait_with_inference_var() {
         r#"
 //- minicore: deref
 struct Arc<T>;
-fn new_arc<T>() -> Arc<T> {}
+fn new_arc<T>() -> Arc<T> { Arc }
 impl<T> core::ops::Deref for Arc<T> {
     type Target = T;
 }
@@ -663,8 +600,8 @@ fn foo(a: Arc<S>) {}
 
 fn test() {
     let a = new_arc();
-    let b = (*a);
-          //^ S
+    let b = *a;
+          //^^ S
     foo(a);
 }
 "#,
@@ -684,7 +621,7 @@ impl core::ops::Deref for S {
 
 fn test(s: S) {
     s.foo();
-}       //^ {unknown}
+} //^^^^^^^ {unknown}
 "#,
     );
 }
@@ -701,12 +638,12 @@ impl<T: ?Sized> core::ops::Deref for Arc<T> {
 
 struct S;
 impl S {
-    fn foo(&self) -> u128 {}
+    fn foo(&self) -> u128 { 0 }
 }
 
 fn test(s: Arc<S>) {
     (*s, s.foo());
-} //^ (S, u128)
+} //^^^^^^^^^^^^^ (S, u128)
 "#,
     );
 }
@@ -720,11 +657,11 @@ struct S;
 trait Trait<T> {}
 impl Trait<u32> for S {}
 
-fn foo<T: Trait<U>, U>(t: T) -> U {}
+fn foo<T: Trait<U>, U>(t: T) -> U { loop {} }
 
 fn test(s: S) {
-    (foo(s));
-} //^ u32
+    foo(s);
+} //^^^^^^ u32
 "#,
     );
 }
@@ -741,12 +678,12 @@ impl Trait<isize> for S {}
 
 struct O;
 impl O {
-    fn foo<T: Trait<U>, U>(&self, t: T) -> U {}
+    fn foo<T: Trait<U>, U>(&self, t: T) -> U { loop {} }
 }
 
 fn test() {
     O.foo(S);
-}      //^ isize
+} //^^^^^^^^ isize
 "#,
     );
 }
@@ -761,12 +698,12 @@ trait Trait<T> {}
 impl Trait<i64> for S {}
 
 impl S {
-    fn foo<U>(&self) -> U where Self: Trait<U> {}
+    fn foo<U>(&self) -> U where Self: Trait<U> { loop {} }
 }
 
 fn test() {
     S.foo();
-}       //^ i64
+} //^^^^^^^ i64
 "#,
     );
 }
@@ -782,12 +719,12 @@ impl Trait<&str> for S {}
 
 struct O<T>;
 impl<U, T: Trait<U>> O<T> {
-    fn foo(&self) -> U {}
+    fn foo(&self) -> U { loop {} }
 }
 
 fn test(o: O<S>) {
     o.foo();
-}       //^ &str
+} //^^^^^^^ &str
 "#,
     );
 }
@@ -802,7 +739,7 @@ struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
 fn test<T: Clone>(t: T) { t.foo(); }
-                             //^ u128
+                        //^^^^^^^ u128
 "#,
     );
 }
@@ -818,7 +755,7 @@ struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
 fn test<T>(t: T) { t.foo(); }
-                       //^ {unknown}
+                 //^^^^^^^ {unknown}
 "#,
     );
 }
@@ -831,7 +768,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
 fn test<T: Trait>(t: T) { t.foo(); }
-                              //^ u128
+                        //^^^^^^^ u128
 "#,
     );
 }
@@ -844,7 +781,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
 fn test<T>(t: T) { t.foo(); }
-                       //^ {unknown}
+                 //^^^^^^^ {unknown}
 "#,
     );
 }
@@ -858,8 +795,8 @@ trait Trait {}
 impl<T> core::ops::Deref for T where T: Trait {
     type Target = i128;
 }
-fn test<T: Trait>(t: T) { (*t); }
-                        //^ i128
+fn test<T: Trait>(t: T) { *t; }
+                        //^^ i128
 "#,
     );
 }
@@ -1380,12 +1317,12 @@ fn error_bound_chalk() {
     check_types(
         r#"
 trait Trait {
-    fn foo(&self) -> u32 {}
+    fn foo(&self) -> u32 { 0 }
 }
 
 fn test(x: (impl Trait + UnknownTrait)) {
     x.foo();
-}       //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -1476,7 +1413,7 @@ trait Clone {
 fn api_walkthrough() {
     for node in foo() {
         node.clone();
-    }            //^ {unknown}
+    } //^^^^^^^^^^^^ {unknown}
 }
 "#,
     );
@@ -1513,13 +1450,13 @@ fn where_clause_trait_in_scope_for_method_resolution() {
         r#"
 mod foo {
     trait Trait {
-        fn foo(&self) -> u32 {}
+        fn foo(&self) -> u32 { 0 }
     }
 }
 
 fn test<T: foo::Trait>(x: T) {
     x.foo();
-}      //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -1982,7 +1919,7 @@ fn fn_item_fn_trait() {
 //- minicore: fn
 struct S;
 
-fn foo() -> S {}
+fn foo() -> S { S }
 
 fn takes_closure<U, F: FnOnce() -> U>(f: F) -> U { f() }
 
@@ -2009,7 +1946,7 @@ trait Trait2 {
 fn test<T: Trait>() where T::Item: Trait2 {
     let x: T::Item = no_matter;
     x.foo();
-}       //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -2029,7 +1966,7 @@ trait Trait2 {
 fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
     let x: T::Item = no_matter;
     x.foo();
-}       //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -2092,7 +2029,7 @@ impl Trait for S {
 
 fn test() {
     S.f();
-}     //^ u32
+} //^^^^^ u32
 "#,
     );
 }
@@ -2120,7 +2057,7 @@ where
 
 fn foo<I: Interner>(interner: &I, t: Ty<I>) {
     fold(interner, t);
-}     //^ Ty<I>
+} //^^^^^^^^^^^^^^^^^ Ty<I>
 "#,
     );
 }
@@ -2139,7 +2076,7 @@ impl Trait<Self> for S {}
 
 fn test() {
     S.foo();
-}       //^ ()
+} //^^^^^^^ ()
 "#,
     );
 }
@@ -2158,7 +2095,7 @@ impl Trait for S<Self> {}
 
 fn test() {
     S.foo();
-}       //^ {unknown}
+} //^^^^^^^ {unknown}
 "#,
     );
 }
@@ -2176,7 +2113,7 @@ trait Trait2<T> {}
 
 fn test<T: Trait>() where T: Trait2<T::Item> {
     let x: T::Item = no_matter;
-}                       //^ {unknown}
+}                  //^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -2193,7 +2130,7 @@ trait Trait<T> {
 
 fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
     let x: T::Item = no_matter;
-}                   //^ {unknown}
+}                  //^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -2211,7 +2148,7 @@ trait Trait {
 
 fn test<T>() where T: Trait<OtherItem = T::Item> {
     let x: T::Item = no_matter;
-}                   //^ Trait::Item<T>
+}                  //^^^^^^^^^ Trait::Item<T>
 "#,
     );
 }
@@ -2243,7 +2180,7 @@ fn test<T>(t: T) where T: UnificationStoreMut {
     t.push(x);
     let y: Key<T>;
     (x, y);
-}      //^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
+} //^^^^^^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
 "#,
     );
 }
@@ -2268,7 +2205,7 @@ impl<T: Iterator> Iterator for S<T> {
 fn test<I: Iterator<Item: OtherTrait<u32>>>() {
     let x: <S<I> as Iterator>::Item;
     x.foo();
-}       //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -2470,7 +2407,7 @@ impl<T: Trait> Trait for S<T> {
 fn test<T: Trait>() {
     let y: <S<T> as Trait>::Item = no_matter;
     y.foo();
-}       //^ u32
+} //^^^^^^^ u32
 "#,
     );
 }
@@ -2490,7 +2427,7 @@ trait Trait {
 
 fn test(x: Box<dyn Trait>) {
     x.foo();
-}       //^ ()
+} //^^^^^^^ ()
 "#,
     );
 }
@@ -2509,7 +2446,7 @@ impl ToOwned for str {
 }
 fn test() {
     "foo".to_owned();
-}               //^ String
+} //^^^^^^^^^^^^^^^^ String
 "#,
     );
 }
@@ -2649,7 +2586,7 @@ impl<T:A> B for T {
 
 fn main() {
     Bar::foo();
-}          //^ Foo
+} //^^^^^^^^^^ Foo
 "#,
     );
 }
@@ -3002,7 +2939,7 @@ fn test() {
     S.get(1);
   //^^^^^^^^ u128
     S.get(1.);
-  //^^^^^^^^ f32
+  //^^^^^^^^^ f32
 }
         "#,
     );
@@ -3477,14 +3414,12 @@ trait Convert {
     fn new() -> Self;
 }
 impl Convert for u32 {
-    fn new() -> Self {
-        0
-    }
+    fn new() -> Self { 0 }
 }
 
 async fn get_accounts() -> Result<u32, ()> {
     let ret = Fooey.collect();
-    //                      ^ u32
+    //        ^^^^^^^^^^^^^^^ u32
     Ok(ret)
 }
 "#,
@@ -3493,6 +3428,7 @@ async fn get_accounts() -> Result<u32, ()> {
 
 #[test]
 fn local_impl_1() {
+    check!(block_local_impls);
     check_types(
         r#"
 trait Trait<T> {
@@ -3502,7 +3438,7 @@ trait Trait<T> {
 fn test() {
     struct S;
     impl Trait<u32> for S {
-        fn foo(&self) { 0 }
+        fn foo(&self) -> u32 { 0 }
     }
 
     S.foo();
@@ -3514,6 +3450,7 @@ fn test() {
 
 #[test]
 fn local_impl_2() {
+    check!(block_local_impls);
     check_types(
         r#"
 struct S;
@@ -3523,7 +3460,7 @@ fn test() {
         fn foo(&self) -> T;
     }
     impl Trait<u32> for S {
-        fn foo(&self) { 0 }
+        fn foo(&self) -> u32 { 0 }
     }
 
     S.foo();
@@ -3535,6 +3472,7 @@ fn test() {
 
 #[test]
 fn local_impl_3() {
+    check!(block_local_impls);
     check_types(
         r#"
 trait Trait<T> {
@@ -3547,7 +3485,7 @@ fn test() {
         struct S2;
 
         impl Trait<S1> for S2 {
-            fn foo(&self) { S1 }
+            fn foo(&self) -> S1 { S1 }
         }
 
         S2.foo();
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 05a2b1293..c6d6bb74a 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,8 +1,5 @@
 use either::Either;
-use hir::{
-    AsAssocItem, AssocItemContainer, GenericParam, HasAttrs, HasSource, HirDisplay, InFile, Module,
-    ModuleDef, Semantics,
-};
+use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
 use ide_db::{
     base_db::SourceDatabase,
     defs::{Definition, NameClass, NameRefClass},
@@ -33,37 +30,20 @@ use crate::{
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct HoverConfig {
-    pub implementations: bool,
-    pub references: bool,
-    pub run: bool,
-    pub debug: bool,
-    pub goto_type_def: bool,
     pub links_in_hover: bool,
-    pub markdown: bool,
+    pub documentation: Option<HoverDocFormat>,
 }
 
 impl HoverConfig {
-    pub const NO_ACTIONS: Self = Self {
-        implementations: false,
-        references: false,
-        run: false,
-        debug: false,
-        goto_type_def: false,
-        links_in_hover: true,
-        markdown: true,
-    };
-
-    pub fn any(&self) -> bool {
-        self.implementations || self.references || self.runnable() || self.goto_type_def
-    }
-
-    pub fn none(&self) -> bool {
-        !self.any()
+    fn markdown(&self) -> bool {
+        matches!(self.documentation, Some(HoverDocFormat::Markdown))
     }
+}
 
-    pub fn runnable(&self) -> bool {
-        self.run || self.debug
-    }
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum HoverDocFormat {
+    Markdown,
+    PlainText,
 }
 
 #[derive(Debug, Clone)]
@@ -96,10 +76,9 @@ pub struct HoverResult {
 pub(crate) fn hover(
     db: &RootDatabase,
     position: FilePosition,
-    links_in_hover: bool,
-    markdown: bool,
+    config: &HoverConfig,
 ) -> Option<RangeInfo<HoverResult>> {
-    let sema = Semantics::new(db);
+    let sema = hir::Semantics::new(db);
     let file = sema.parse(position.file_id).syntax().clone();
     let token = pick_best(file.token_at_offset(position.offset))?;
     let token = sema.descend_into_macros(token);
@@ -131,7 +110,7 @@ pub(crate) fn hover(
                     let (docs, doc_mapping) = attributes.docs_with_rangemap(db)?;
                     let (idl_range, link, ns) =
                         extract_definitions_from_markdown(docs.as_str()).into_iter().find_map(|(range, link, ns)| {
-                            let InFile { file_id, value: range } = doc_mapping.map(range)?;
+                            let hir::InFile { file_id, value: range } = doc_mapping.map(range)?;
                             if file_id == position.file_id.into() && range.contains(position.offset) {
                                 Some((range, link, ns))
                             } else {
@@ -151,13 +130,13 @@ pub(crate) fn hover(
 
     if let Some(definition) = definition {
         let famous_defs = match &definition {
-            Definition::ModuleDef(ModuleDef::BuiltinType(_)) => {
+            Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
                 Some(FamousDefs(&sema, sema.scope(&node).krate()))
             }
             _ => None,
         };
-        if let Some(markup) = hover_for_definition(db, definition, famous_defs.as_ref()) {
-            res.markup = process_markup(sema.db, definition, &markup, links_in_hover, markdown);
+        if let Some(markup) = hover_for_definition(db, definition, famous_defs.as_ref(), config) {
+            res.markup = process_markup(sema.db, definition, &markup, config);
             if let Some(action) = show_implementations_action(db, definition) {
                 res.actions.push(action);
             }
@@ -179,7 +158,7 @@ pub(crate) fn hover(
         }
     }
 
-    if let res @ Some(_) = hover_for_keyword(&sema, links_in_hover, markdown, &token) {
+    if let res @ Some(_) = hover_for_keyword(&sema, config, &token) {
         return res;
     }
 
@@ -198,7 +177,7 @@ pub(crate) fn hover(
         }
     };
 
-    res.markup = if markdown {
+    res.markup = if config.markdown() {
         Markup::fenced_block(&ty.display(db))
     } else {
         ty.display(db).to_string().into()
@@ -261,8 +240,10 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
     }
 
     let adt = match def {
-        Definition::ModuleDef(ModuleDef::Trait(it)) => return it.try_to_nav(db).map(to_action),
-        Definition::ModuleDef(ModuleDef::Adt(it)) => Some(it),
+        Definition::ModuleDef(hir::ModuleDef::Trait(it)) => {
+            return it.try_to_nav(db).map(to_action)
+        }
+        Definition::ModuleDef(hir::ModuleDef::Adt(it)) => Some(it),
         Definition::SelfType(it) => it.self_ty(db).as_adt(),
         _ => None,
     }?;
@@ -271,25 +252,27 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
 
 fn show_fn_references_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
     match def {
-        Definition::ModuleDef(ModuleDef::Function(it)) => it.try_to_nav(db).map(|nav_target| {
-            HoverAction::Reference(FilePosition {
-                file_id: nav_target.file_id,
-                offset: nav_target.focus_or_full_range().start(),
+        Definition::ModuleDef(hir::ModuleDef::Function(it)) => {
+            it.try_to_nav(db).map(|nav_target| {
+                HoverAction::Reference(FilePosition {
+                    file_id: nav_target.file_id,
+                    offset: nav_target.focus_or_full_range().start(),
+                })
             })
-        }),
+        }
         _ => None,
     }
 }
 
 fn runnable_action(
-    sema: &Semantics<RootDatabase>,
+    sema: &hir::Semantics<RootDatabase>,
     def: Definition,
     file_id: FileId,
 ) -> Option<HoverAction> {
     match def {
         Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => runnable_mod(sema, it).map(HoverAction::Runnable),
-            ModuleDef::Function(func) => {
+            hir::ModuleDef::Module(it) => runnable_mod(sema, it).map(HoverAction::Runnable),
+            hir::ModuleDef::Function(func) => {
                 let src = func.source(sema.db)?;
                 if src.file_id != file_id.into() {
                     cov_mark::hit!(hover_macro_generated_struct_fn_doc_comment);
@@ -306,19 +289,19 @@ fn runnable_action(
 }
 
 fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
-    let mut targets: Vec<ModuleDef> = Vec::new();
-    let mut push_new_def = |item: ModuleDef| {
+    let mut targets: Vec<hir::ModuleDef> = Vec::new();
+    let mut push_new_def = |item: hir::ModuleDef| {
         if !targets.contains(&item) {
             targets.push(item);
         }
     };
 
-    if let Definition::GenericParam(GenericParam::TypeParam(it)) = def {
+    if let Definition::GenericParam(hir::GenericParam::TypeParam(it)) = def {
         it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
     } else {
         let ty = match def {
             Definition::Local(it) => it.ty(db),
-            Definition::GenericParam(GenericParam::ConstParam(it)) => it.ty(db),
+            Definition::GenericParam(hir::GenericParam::ConstParam(it)) => it.ty(db),
             _ => return None,
         };
 
@@ -348,42 +331,32 @@ fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
     Some(HoverAction::GoToType(targets))
 }
 
-fn hover_markup(
-    docs: Option<String>,
-    desc: Option<String>,
-    mod_path: Option<String>,
-) -> Option<Markup> {
-    match desc {
-        Some(desc) => {
-            let mut buf = String::new();
-
-            if let Some(mod_path) = mod_path {
-                if !mod_path.is_empty() {
-                    format_to!(buf, "```rust\n{}\n```\n\n", mod_path);
-                }
-            }
-            format_to!(buf, "```rust\n{}\n```", desc);
+fn hover_markup(docs: Option<String>, desc: String, mod_path: Option<String>) -> Option<Markup> {
+    let mut buf = String::new();
 
-            if let Some(doc) = docs {
-                format_to!(buf, "\n___\n\n{}", doc);
-            }
-            Some(buf.into())
+    if let Some(mod_path) = mod_path {
+        if !mod_path.is_empty() {
+            format_to!(buf, "```rust\n{}\n```\n\n", mod_path);
         }
-        None => docs.map(Markup::from),
     }
+    format_to!(buf, "```rust\n{}\n```", desc);
+
+    if let Some(doc) = docs {
+        format_to!(buf, "\n___\n\n{}", doc);
+    }
+    Some(buf.into())
 }
 
 fn process_markup(
     db: &RootDatabase,
     def: Definition,
     markup: &Markup,
-    links_in_hover: bool,
-    markdown: bool,
+    config: &HoverConfig,
 ) -> Markup {
     let markup = markup.as_str();
-    let markup = if !markdown {
+    let markup = if !config.markdown() {
         remove_markdown(markup)
-    } else if links_in_hover {
+    } else if config.links_in_hover {
         rewrite_links(db, markup, &def)
     } else {
         remove_links(markup)
@@ -396,11 +369,11 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
         Definition::Field(f) => Some(f.parent_def(db).name(db)),
         Definition::Local(l) => l.parent(db).name(db),
         Definition::ModuleDef(md) => match md {
-            ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) {
-                AssocItemContainer::Trait(t) => Some(t.name(db)),
-                AssocItemContainer::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)),
+            hir::ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) {
+                hir::AssocItemContainer::Trait(t) => Some(t.name(db)),
+                hir::AssocItemContainer::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)),
             },
-            ModuleDef::Variant(e) => Some(e.parent_enum(db).name(db)),
+            hir::ModuleDef::Variant(e) => Some(e.parent_enum(db).name(db)),
             _ => None,
         },
         _ => None,
@@ -408,7 +381,7 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
     .map(|name| name.to_string())
 }
 
-fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) -> String {
+fn render_path(db: &RootDatabase, module: hir::Module, item_name: Option<String>) -> String {
     let crate_name =
         db.crate_graph()[module.krate().into()].display_name.as_ref().map(|it| it.to_string());
     let module_path = module
@@ -420,6 +393,9 @@ fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) ->
 }
 
 fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+    if let Definition::GenericParam(_) = def {
+        return None;
+    }
     def.module(db).map(|module| render_path(db, module, definition_owner_name(db, def)))
 }
 
@@ -427,60 +403,57 @@ fn hover_for_definition(
     db: &RootDatabase,
     def: Definition,
     famous_defs: Option<&FamousDefs>,
+    config: &HoverConfig,
 ) -> Option<Markup> {
     let mod_path = definition_mod_path(db, &def);
-    return match def {
+    let (label, docs) = match def {
         Definition::Macro(it) => match &it.source(db)?.value {
             Either::Left(mac) => {
                 let label = macro_label(mac);
-                from_def_source_labeled(db, it, Some(label), mod_path)
+                (label, it.attrs(db).docs())
             }
             Either::Right(_) => {
                 // FIXME
-                None
+                return None;
             }
         },
-        Definition::Field(def) => from_hir_fmt(db, def, mod_path),
+        Definition::Field(def) => label_and_docs(db, def),
         Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Function(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Adt(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Variant(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Const(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Static(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Trait(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::TypeAlias(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::BuiltinType(it) => famous_defs
-                .and_then(|fd| hover_for_builtin(fd, it))
-                .or_else(|| Some(Markup::fenced_block(&it.name()))),
+            hir::ModuleDef::Module(it) => label_and_docs(db, it),
+            hir::ModuleDef::Function(it) => label_and_docs(db, it),
+            hir::ModuleDef::Adt(it) => label_and_docs(db, it),
+            hir::ModuleDef::Variant(it) => label_and_docs(db, it),
+            hir::ModuleDef::Const(it) => label_and_docs(db, it),
+            hir::ModuleDef::Static(it) => label_and_docs(db, it),
+            hir::ModuleDef::Trait(it) => label_and_docs(db, it),
+            hir::ModuleDef::TypeAlias(it) => label_and_docs(db, it),
+            hir::ModuleDef::BuiltinType(it) => {
+                return famous_defs
+                    .and_then(|fd| hover_for_builtin(fd, it))
+                    .or_else(|| Some(Markup::fenced_block(&it.name())))
+            }
         },
-        Definition::Local(it) => hover_for_local(it, db),
+        Definition::Local(it) => return hover_for_local(it, db),
         Definition::SelfType(impl_def) => {
-            impl_def.self_ty(db).as_adt().and_then(|adt| from_hir_fmt(db, adt, mod_path))
+            impl_def.self_ty(db).as_adt().map(|adt| label_and_docs(db, adt))?
         }
-        Definition::GenericParam(it) => from_hir_fmt(db, it, None),
-        Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
+        Definition::GenericParam(it) => label_and_docs(db, it),
+        Definition::Label(it) => return Some(Markup::fenced_block(&it.name(db))),
     };
 
-    fn from_hir_fmt<D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
+    return hover_markup(
+        docs.filter(|_| config.documentation.is_some()).map(Into::into),
+        label,
+        mod_path,
+    );
+
+    fn label_and_docs<D>(db: &RootDatabase, def: D) -> (String, Option<hir::Documentation>)
     where
         D: HasAttrs + HirDisplay,
     {
         let label = def.display(db).to_string();
-        from_def_source_labeled(db, def, Some(label), mod_path)
-    }
-
-    fn from_def_source_labeled<D>(
-        db: &RootDatabase,
-        def: D,
-        short_label: Option<String>,
-        mod_path: Option<String>,
-    ) -> Option<Markup>
-    where
-        D: HasAttrs,
-    {
-        let docs = def.attrs(db).docs().map(Into::into);
-        hover_markup(docs, short_label, mod_path)
+        let docs = def.attrs(db).docs();
+        (label, docs)
     }
 }
 
@@ -504,16 +477,15 @@ fn hover_for_local(it: hir::Local, db: &RootDatabase) -> Option<Markup> {
         }
         Either::Right(_) => format!("{}self: {}", is_mut, ty),
     };
-    hover_markup(None, Some(desc), None)
+    hover_markup(None, desc, None)
 }
 
 fn hover_for_keyword(
     sema: &Semantics<RootDatabase>,
-    links_in_hover: bool,
-    markdown: bool,
+    config: &HoverConfig,
     token: &SyntaxToken,
 ) -> Option<RangeInfo<HoverResult>> {
-    if !token.kind().is_keyword() {
+    if !token.kind().is_keyword() || !config.documentation.is_some() {
         return None;
     }
     let famous_defs = FamousDefs(sema, sema.scope(&token.parent()?).krate());
@@ -524,9 +496,8 @@ fn hover_for_keyword(
     let markup = process_markup(
         sema.db,
         Definition::ModuleDef(doc_owner.into()),
-        &hover_markup(Some(docs.into()), Some(token.text().into()), None)?,
-        links_in_hover,
-        markdown,
+        &hover_markup(Some(docs.into()), token.text().into(), None)?,
+        config,
     );
     Some(RangeInfo::new(token.text_range(), HoverResult { markup, actions: Default::default() }))
 }
@@ -536,7 +507,7 @@ fn hover_for_builtin(famous_defs: &FamousDefs, builtin: hir::BuiltinType) -> Opt
     let primitive_mod = format!("prim_{}", builtin.name());
     let doc_owner = find_std_module(famous_defs, &primitive_mod)?;
     let docs = doc_owner.attrs(famous_defs.0.db).docs()?;
-    hover_markup(Some(docs.into()), Some(builtin.name().to_string()), None)
+    hover_markup(Some(docs.into()), builtin.name().to_string(), None)
 }
 
 fn find_std_module(famous_defs: &FamousDefs, name: &str) -> Option<hir::Module> {
@@ -566,16 +537,34 @@ mod tests {
     use expect_test::{expect, Expect};
     use ide_db::base_db::FileLoader;
 
-    use crate::fixture;
+    use crate::{fixture, hover::HoverDocFormat, HoverConfig};
 
     fn check_hover_no_result(ra_fixture: &str) {
         let (analysis, position) = fixture::position(ra_fixture);
-        assert!(analysis.hover(position, true, true).unwrap().is_none());
+        assert!(analysis
+            .hover(
+                position,
+                &HoverConfig {
+                    links_in_hover: true,
+                    documentation: Some(HoverDocFormat::Markdown)
+                }
+            )
+            .unwrap()
+            .is_none());
     }
 
     fn check(ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, true, true).unwrap().unwrap();
+        let hover = analysis
+            .hover(
+                position,
+                &HoverConfig {
+                    links_in_hover: true,
+                    documentation: Some(HoverDocFormat::Markdown),
+                },
+            )
+            .unwrap()
+            .unwrap();
 
         let content = analysis.db.file_text(position.file_id);
         let hovered_element = &content[hover.range];
@@ -586,7 +575,16 @@ mod tests {
 
     fn check_hover_no_links(ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, false, true).unwrap().unwrap();
+        let hover = analysis
+            .hover(
+                position,
+                &HoverConfig {
+                    links_in_hover: false,
+                    documentation: Some(HoverDocFormat::Markdown),
+                },
+            )
+            .unwrap()
+            .unwrap();
 
         let content = analysis.db.file_text(position.file_id);
         let hovered_element = &content[hover.range];
@@ -597,7 +595,16 @@ mod tests {
 
     fn check_hover_no_markdown(ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, true, false).unwrap().unwrap();
+        let hover = analysis
+            .hover(
+                position,
+                &HoverConfig {
+                    links_in_hover: true,
+                    documentation: Some(HoverDocFormat::PlainText),
+                },
+            )
+            .unwrap()
+            .unwrap();
 
         let content = analysis.db.file_text(position.file_id);
         let hovered_element = &content[hover.range];
@@ -608,7 +615,16 @@ mod tests {
 
     fn check_actions(ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, true, true).unwrap().unwrap();
+        let hover = analysis
+            .hover(
+                position,
+                &HoverConfig {
+                    links_in_hover: true,
+                    documentation: Some(HoverDocFormat::Markdown),
+                },
+            )
+            .unwrap()
+            .unwrap();
         expect.assert_debug_eq(&hover.info.actions)
     }
 
@@ -2258,7 +2274,7 @@ pub fn fo$0o() {}
                 case 13. collapsed link: foo
                 case 14. shortcut link: foo
                 case 15. inline without URL: foo
-                case 16. just escaped text: \[foo]
+                case 16. just escaped text: \[foo\]
                 case 17. inline link: Foo
 
                 [^example]: https://www.example.com/
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 4bd073cc3..b978e36af 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -75,7 +75,7 @@ pub use crate::{
     expand_macro::ExpandedMacro,
     file_structure::{StructureNode, StructureNodeKind},
     folding_ranges::{Fold, FoldKind},
-    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
+    hover::{HoverAction, HoverConfig, HoverDocFormat, HoverGotoTypeData, HoverResult},
     inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
     markup::Markup,
     move_item::Direction,
@@ -217,6 +217,7 @@ impl Analysis {
             file_id,
             Edition::Edition2018,
             None,
+            cfg_options.clone(),
             cfg_options,
             Env::default(),
             Default::default(),
@@ -407,10 +408,9 @@ impl Analysis {
     pub fn hover(
         &self,
         position: FilePosition,
-        links_in_hover: bool,
-        markdown: bool,
+        config: &HoverConfig,
     ) -> Cancellable<Option<RangeInfo<HoverResult>>> {
-        self.with_db(|db| hover::hover(db, position, links_in_hover, markdown))
+        self.with_db(|db| hover::hover(db, position, config))
     }
 
     /// Return URL(s) for the documentation of the symbol under the cursor.
diff --git a/crates/ide/src/rename.rs b/crates/ide/src/rename.rs
index 8096dfa0e..96bd07708 100644
--- a/crates/ide/src/rename.rs
+++ b/crates/ide/src/rename.rs
@@ -10,7 +10,7 @@ use ide_db::{
     rename::{bail, format_err, source_edit_from_references, IdentifierKind},
     RootDatabase,
 };
-use stdx::never;
+use stdx::{always, never};
 use syntax::{ast, AstNode, SyntaxNode};
 
 use text_edit::TextEdit;
@@ -31,10 +31,13 @@ pub(crate) fn prepare_rename(
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
 
-    let def = find_definition(&sema, syntax, position)?;
-    let frange = def
-        .range_for_rename(&sema)
-        .ok_or_else(|| format_err!("No references found at position"))?;
+    let (name_like, def) = find_definition(&sema, syntax, position)?;
+    if def.range_for_rename(&sema).is_none() {
+        bail!("No references found at position")
+    }
+
+    let frange = sema.original_range(name_like.syntax());
+    always!(frange.range.contains_inclusive(position.offset) && frange.file_id == position.file_id);
     Ok(RangeInfo::new(frange.range, ()))
 }
 
@@ -55,31 +58,23 @@ pub(crate) fn rename(
     new_name: &str,
 ) -> RenameResult<SourceChange> {
     let sema = Semantics::new(db);
-    rename_with_semantics(&sema, position, new_name)
-}
-
-pub(crate) fn rename_with_semantics(
-    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
-    new_name: &str,
-) -> RenameResult<SourceChange> {
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
 
-    let def = find_definition(sema, syntax, position)?;
+    let (_name_like, def) = find_definition(&sema, syntax, position)?;
 
     if let Definition::Local(local) = def {
         if let Some(self_param) = local.as_self_param(sema.db) {
             cov_mark::hit!(rename_self_to_param);
-            return rename_self_to_param(sema, local, self_param, new_name);
+            return rename_self_to_param(&sema, local, self_param, new_name);
         }
         if new_name == "self" {
             cov_mark::hit!(rename_to_self);
-            return rename_to_self(sema, local);
+            return rename_to_self(&sema, local);
         }
     }
 
-    def.rename(sema, new_name)
+    def.rename(&sema, new_name)
 }
 
 /// Called by the client when it is about to rename a file.
@@ -100,11 +95,12 @@ fn find_definition(
     sema: &Semantics<RootDatabase>,
     syntax: &SyntaxNode,
     position: FilePosition,
-) -> RenameResult<Definition> {
-    match sema
-        .find_node_at_offset_with_descend(syntax, position.offset)
-        .ok_or_else(|| format_err!("No references found at position"))?
-    {
+) -> RenameResult<(ast::NameLike, Definition)> {
+    let name_like = sema
+        .find_node_at_offset_with_descend::<ast::NameLike>(syntax, position.offset)
+        .ok_or_else(|| format_err!("No references found at position"))?;
+
+    let def = match &name_like {
         // renaming aliases would rename the item being aliased as the HIR doesn't track aliases yet
         ast::NameLike::Name(name)
             if name.syntax().parent().map_or(false, |it| ast::Rename::can_cast(it.kind())) =>
@@ -134,7 +130,9 @@ fn find_definition(
                     .map(|it| it.referenced_or_defined(sema.db))
             }),
     }
-    .ok_or_else(|| format_err!("No references found at position"))
+    .ok_or_else(|| format_err!("No references found at position"))?;
+
+    Ok((name_like, def))
 }
 
 fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
@@ -328,7 +326,7 @@ mod tests {
     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#"3..7: name"#]]);
+        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
     }
 
     #[test]
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index 4ad49eca0..37ae92350 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -23,7 +23,7 @@ use syntax::{
     algo::find_node_at_offset,
     ast::{self, edit::IndentLevel, AstToken},
     AstNode, Parse, SourceFile,
-    SyntaxKind::{FIELD_EXPR, METHOD_CALL_EXPR},
+    SyntaxKind::{self, FIELD_EXPR, METHOD_CALL_EXPR},
     TextRange, TextSize,
 };
 
@@ -95,9 +95,16 @@ fn on_opening_brace_typed(file: &Parse<SourceFile>, offset: TextSize) -> Option<
     }
 
     let brace_token = file.tree().syntax().token_at_offset(offset).right_biased()?;
+    if brace_token.kind() != SyntaxKind::L_CURLY {
+        return None;
+    }
 
-    // Remove the `{` to get a better parse tree, and reparse
-    let file = file.reparse(&Indel::delete(brace_token.text_range()));
+    // Remove the `{` to get a better parse tree, and reparse.
+    let range = brace_token.text_range();
+    if !stdx::always!(range.len() == TextSize::of('{')) {
+        return None;
+    }
+    let file = file.reparse(&Indel::delete(range));
 
     if let Some(edit) = brace_expr(&file.tree(), offset) {
         return Some(edit);
@@ -550,6 +557,29 @@ fn f() {
     }
 
     #[test]
+    fn noop_in_string_literal() {
+        // Regression test for #9351
+        type_char_noop(
+            '{',
+            r##"
+fn check_with(ra_fixture: &str, expect: Expect) {
+    let base = r#"
+enum E { T(), R$0, C }
+use self::E::X;
+const Z: E = E::C;
+mod m {}
+asdasdasdasdasdasda
+sdasdasdasdasdasda
+sdasdasdasdasd
+"#;
+    let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+            "##,
+        );
+    }
+
+    #[test]
     fn adds_closing_brace_for_use_tree() {
         type_char(
             '{',
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index ac7f0959b..870d4f665 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -109,10 +109,15 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option
 
             let new_indent = IndentLevel::from_node(&insert_after);
             let old_indent = fun.body.indent_level();
+            let body_contains_await = body_contains_await(&fun.body);
 
-            builder.replace(target_range, format_replacement(ctx, &fun, old_indent));
+            builder.replace(
+                target_range,
+                format_replacement(ctx, &fun, old_indent, body_contains_await),
+            );
 
-            let fn_def = format_function(ctx, module, &fun, old_indent, new_indent);
+            let fn_def =
+                format_function(ctx, module, &fun, old_indent, new_indent, body_contains_await);
             let insert_offset = insert_after.text_range().end();
             match ctx.config.snippet_cap {
                 Some(cap) => builder.insert_snippet(cap, insert_offset, fn_def),
@@ -954,7 +959,12 @@ fn scope_for_fn_insertion_node(node: &SyntaxNode, anchor: Anchor) -> Option<Synt
     last_ancestor
 }
 
-fn format_replacement(ctx: &AssistContext, fun: &Function, indent: IndentLevel) -> String {
+fn format_replacement(
+    ctx: &AssistContext,
+    fun: &Function,
+    indent: IndentLevel,
+    body_contains_await: bool,
+) -> String {
     let ret_ty = fun.return_type(ctx);
 
     let args = fun.params.iter().map(|param| param.to_arg(ctx));
@@ -994,6 +1004,9 @@ fn format_replacement(ctx: &AssistContext, fun: &Function, indent: IndentLevel)
         }
     }
     format_to!(buf, "{}", expr);
+    if body_contains_await {
+        buf.push_str(".await");
+    }
     if fun.ret_ty.is_unit()
         && (!fun.vars_defined_in_body_and_outlive.is_empty() || !expr.is_block_like())
     {
@@ -1122,12 +1135,13 @@ fn format_function(
     fun: &Function,
     old_indent: IndentLevel,
     new_indent: IndentLevel,
+    body_contains_await: bool,
 ) -> String {
     let mut fn_def = String::new();
     let params = make_param_list(ctx, module, fun);
     let ret_ty = make_ret_ty(ctx, module, fun);
     let body = make_body(ctx, old_indent, new_indent, fun);
-    let async_kw = if body_contains_await(&fun.body) { "async " } else { "" };
+    let async_kw = if body_contains_await { "async " } else { "" };
     match ctx.config.snippet_cap {
         Some(_) => format_to!(fn_def, "\n\n{}{}fn $0{}{}", new_indent, async_kw, fun.name, params),
         None => format_to!(fn_def, "\n\n{}{}fn {}{}", new_indent, async_kw, fun.name, params),
@@ -3681,7 +3695,7 @@ async fn some_function() {
 "#,
             r#"
 fn main() {
-    fun_name();
+    fun_name().await;
 }
 
 async fn $0fun_name() {
@@ -3710,7 +3724,7 @@ async fn some_function() {
 "#,
             r#"
 fn main() {
-    fun_name();
+    fun_name().await;
 }
 
 async fn $0fun_name() {
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index 78fc30e16..cc4f4b2af 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -15,6 +15,7 @@ use crate::{
     Completions,
 };
 
+mod cfg;
 mod derive;
 mod lint;
 mod repr;
@@ -30,6 +31,9 @@ pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
                 lint::complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINTS);
                 lint::complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
             }
+            "cfg" => {
+                cfg::complete_cfg(acc, ctx);
+            }
             _ => (),
         },
         (None, Some(_)) => (),
@@ -852,4 +856,15 @@ mod tests {
             "#]],
         );
     }
+
+    #[test]
+    fn test_cfg() {
+        check(
+            r#"#[cfg(target_endian = $0"#,
+            expect![[r#"
+                at little
+                at big
+"#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/completions/attribute/cfg.rs b/crates/ide_completion/src/completions/attribute/cfg.rs
new file mode 100644
index 000000000..847e6529a
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/cfg.rs
@@ -0,0 +1,112 @@
+//! Completion for cfg
+
+use std::iter;
+
+use syntax::SyntaxKind;
+
+use crate::{
+    completions::Completions, context::CompletionContext, item::CompletionKind, CompletionItem,
+    CompletionItemKind,
+};
+
+pub(crate) fn complete_cfg(acc: &mut Completions, ctx: &CompletionContext) {
+    let add_completion = |item: &&str| {
+        let mut completion =
+            CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), *item);
+        completion.insert_text(format!(r#""{}""#, item));
+        completion.kind(CompletionItemKind::Attribute);
+        acc.add(completion.build());
+    };
+
+    let previous = iter::successors(ctx.original_token.prev_token(), |t| {
+        (matches!(t.kind(), SyntaxKind::EQ) || t.kind().is_trivia())
+            .then(|| t.prev_token())
+            .flatten()
+    })
+    .find(|t| matches!(t.kind(), SyntaxKind::IDENT));
+
+    match previous.as_ref().map(|p| p.text()) {
+        Some("target_arch") => KNOWN_ARCH.iter().for_each(add_completion),
+        Some("target_env") => KNOWN_ENV.iter().for_each(add_completion),
+        Some("target_os") => KNOWN_OS.iter().for_each(add_completion),
+        Some("target_vendor") => KNOWN_VENDOR.iter().for_each(add_completion),
+        Some("target_endian") => ["little", "big"].iter().for_each(add_completion),
+        Some(name) => {
+            ctx.krate.map(|krate| {
+                krate.potential_cfg(ctx.db).get_cfg_values(&name).iter().for_each(|s| {
+                    let mut item = CompletionItem::new(
+                        CompletionKind::Attribute,
+                        ctx.source_range(),
+                        s.as_str(),
+                    );
+                    item.insert_text(format!(r#""{}""#, s));
+
+                    acc.add(item.build());
+                })
+            });
+        }
+        None => {
+            ctx.krate.map(|krate| {
+                krate.potential_cfg(ctx.db).get_cfg_keys().iter().for_each(|s| {
+                    let item = CompletionItem::new(
+                        CompletionKind::Attribute,
+                        ctx.source_range(),
+                        s.as_str(),
+                    );
+                    acc.add(item.build());
+                })
+            });
+        }
+    };
+}
+
+const KNOWN_ARCH: [&'static str; 19] = [
+    "aarch64",
+    "arm",
+    "avr",
+    "hexagon",
+    "mips",
+    "mips64",
+    "msp430",
+    "nvptx64",
+    "powerpc",
+    "powerpc64",
+    "riscv32",
+    "riscv64",
+    "s390x",
+    "sparc",
+    "sparc64",
+    "wasm32",
+    "wasm64",
+    "x86",
+    "x86_64",
+];
+
+const KNOWN_ENV: [&'static str; 7] =
+    ["eabihf", "gnu", "gnueabihf", "msvc", "relibc", "sgx", "uclibc"];
+
+const KNOWN_OS: [&'static str; 20] = [
+    "cuda",
+    "dragonfly",
+    "emscripten",
+    "freebsd",
+    "fuchsia",
+    "haiku",
+    "hermit",
+    "illumos",
+    "l4re",
+    "linux",
+    "netbsd",
+    "none",
+    "openbsd",
+    "psp",
+    "redox",
+    "solaris",
+    "uefi",
+    "unknown",
+    "vxworks",
+    "windows",
+];
+
+const KNOWN_VENDOR: [&'static str; 8] =
+    ["apple", "fortanix", "nvidia", "pc", "sony", "unknown", "wrs", "uwp"];
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 07541c79c..407f796ef 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -92,7 +92,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     }
 
     if !ctx.has_visibility_prev_sibling()
-        && (expects_item || ctx.expects_non_trait_assoc_item() || ctx.expect_record_field())
+        && (expects_item || ctx.expects_non_trait_assoc_item() || ctx.expect_field())
     {
         add_keyword("pub(crate)", "pub(crate) ");
         add_keyword("pub", "pub ");
@@ -122,6 +122,10 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword("union", "union $1 {\n    $0\n}");
     }
 
+    if ctx.expects_type() {
+        return;
+    }
+
     if ctx.expects_expression() {
         if !has_block_expr_parent {
             add_keyword("unsafe", "unsafe {\n    $0\n}");
@@ -373,28 +377,6 @@ fn quux() -> i32 {
     }
 
     #[test]
-    fn test_mut_in_ref_and_in_fn_parameters_list() {
-        check(
-            r"fn my_fn(&$0) {}",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-        check(
-            r"fn my_fn($0) {}",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-        check(
-            r"fn my_fn() { let &$0 }",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-    }
-
-    #[test]
     fn no_keyword_completion_in_comments() {
         cov_mark::check!(no_keyword_completion_in_comments);
         check(
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index efe3c957a..bd13a62d7 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -55,398 +55,3 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
         }
     });
 }
-
-#[cfg(test)]
-mod tests {
-    use expect_test::{expect, Expect};
-
-    use crate::{
-        tests::{check_edit, filtered_completion_list},
-        CompletionKind,
-    };
-
-    fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Reference);
-        expect.assert_eq(&actual)
-    }
-
-    fn check_snippet(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Snippet);
-        expect.assert_eq(&actual)
-    }
-
-    #[test]
-    fn completes_enum_variants_and_modules() {
-        check(
-            r#"
-enum E { X }
-use self::E::X;
-const Z: E = E::X;
-mod m {}
-
-static FOO: E = E::X;
-struct Bar { f: u32 }
-
-fn foo() {
-   match E::X { a$0 }
-}
-"#,
-            expect![[r#"
-                en E
-                ct Z
-                st Bar
-                ev X
-                md m
-            "#]],
-        );
-    }
-
-    #[test]
-    fn does_not_complete_non_fn_macros() {
-        check(
-            r#"
-macro_rules! m { ($e:expr) => { $e } }
-enum E { X }
-
-#[rustc_builtin_macro]
-macro Clone {}
-
-fn foo() {
-   match E::X { $0 }
-}
-"#,
-            expect![[r#"
-                ev E::X  ()
-                en E
-                ma m!(…) macro_rules! m
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_in_simple_macro_call() {
-        check(
-            r#"
-macro_rules! m { ($e:expr) => { $e } }
-enum E { X }
-
-fn foo() {
-   m!(match E::X { a$0 })
-}
-"#,
-            expect![[r#"
-                ev E::X  ()
-                en E
-                ma m!(…) macro_rules! m
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_in_irrefutable_let() {
-        check(
-            r#"
-enum E { X }
-use self::E::X;
-const Z: E = E::X;
-mod m {}
-
-static FOO: E = E::X;
-struct Bar { f: u32 }
-
-fn foo() {
-   let a$0
-}
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_in_param() {
-        check(
-            r#"
-enum E { X }
-
-static FOO: E = E::X;
-struct Bar { f: u32 }
-
-fn foo(a$0) {
-}
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_pat_in_let() {
-        check_snippet(
-            r#"
-struct Bar { f: u32 }
-
-fn foo() {
-   let a$0
-}
-"#,
-            expect![[r#"
-                bn Bar Bar { f$1 }$0
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_param_pattern() {
-        check_snippet(
-            r#"
-struct Foo { bar: String, baz: String }
-struct Bar(String, String);
-struct Baz;
-fn outer(a$0) {}
-"#,
-            expect![[r#"
-                bn Foo Foo { bar$1, baz$2 }: Foo$0
-                bn Bar Bar($1, $2): Bar$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_let_pattern() {
-        check_snippet(
-            r#"
-struct Foo { bar: String, baz: String }
-struct Bar(String, String);
-struct Baz;
-fn outer() {
-    let a$0
-}
-"#,
-            expect![[r#"
-                bn Foo Foo { bar$1, baz$2 }$0
-                bn Bar Bar($1, $2)$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_refutable_pattern() {
-        check_snippet(
-            r#"
-struct Foo { bar: i32, baz: i32 }
-struct Bar(String, String);
-struct Baz;
-fn outer() {
-    match () {
-        a$0
-    }
-}
-"#,
-            expect![[r#"
-                bn Foo Foo { bar$1, baz$2 }$0
-                bn Bar Bar($1, $2)$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn omits_private_fields_pat() {
-        check_snippet(
-            r#"
-mod foo {
-    pub struct Foo { pub bar: i32, baz: i32 }
-    pub struct Bar(pub String, String);
-    pub struct Invisible(String, String);
-}
-use foo::*;
-
-fn outer() {
-    match () {
-        a$0
-    }
-}
-"#,
-            expect![[r#"
-                bn Foo Foo { bar$1, .. }$0
-                bn Bar Bar($1, ..)$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn only_shows_ident_completion() {
-        check_edit(
-            "Foo",
-            r#"
-struct Foo(i32);
-fn main() {
-    match Foo(92) {
-        a$0(92) => (),
-    }
-}
-"#,
-            r#"
-struct Foo(i32);
-fn main() {
-    match Foo(92) {
-        Foo(92) => (),
-    }
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn completes_self_pats() {
-        check_snippet(
-            r#"
-struct Foo(i32);
-impl Foo {
-    fn foo() {
-        match () {
-            a$0
-        }
-    }
-}
-    "#,
-            expect![[r#"
-                bn Self Self($1)$0
-                bn Foo  Foo($1)$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_qualified_variant() {
-        check_snippet(
-            r#"
-enum Foo {
-    Bar { baz: i32 }
-}
-impl Foo {
-    fn foo() {
-        match {Foo::Bar { baz: 0 }} {
-            B$0
-        }
-    }
-}
-    "#,
-            expect![[r#"
-                bn Self::Bar Self::Bar { baz$1 }$0
-                bn Foo::Bar  Foo::Bar { baz$1 }$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_enum_variant_matcharm() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-
-fn main() {
-    let foo = Foo::Quux;
-    match foo { Qu$0 }
-}
-"#,
-            expect![[r#"
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-                en Foo
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_enum_variant_matcharm_ref() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-
-fn main() {
-    let foo = Foo::Quux;
-    match &foo { Qu$0 }
-}
-"#,
-            expect![[r#"
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-                en Foo
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_enum_variant_iflet() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-
-fn main() {
-    let foo = Foo::Quux;
-    if let Qu$0 = foo { }
-}
-"#,
-            expect![[r#"
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-                en Foo
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_enum_variant_impl() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-impl Foo {
-    fn foo() { match Foo::Bar { Q$0 } }
-}
-"#,
-            expect![[r#"
-                ev Self::Bar  ()
-                ev Self::Baz  ()
-                ev Self::Quux ()
-                ev Foo::Bar   ()
-                ev Foo::Baz   ()
-                ev Foo::Quux  ()
-                sp Self
-                en Foo
-            "#]],
-        )
-    }
-
-    #[test]
-    fn completes_in_record_field_pat() {
-        check_snippet(
-            r#"
-struct Foo { bar: Bar }
-struct Bar(u32);
-fn outer(Foo { bar: $0 }: Foo) {}
-"#,
-            expect![[r#"
-                bn Foo Foo { bar$1 }$0
-                bn Bar Bar($1)$0
-            "#]],
-        )
-    }
-
-    #[test]
-    fn skips_in_record_field_pat_name() {
-        check_snippet(
-            r#"
-struct Foo { bar: Bar }
-struct Bar(u32);
-fn outer(Foo { bar$0 }: Foo) {}
-"#,
-            expect![[r#""#]],
-        )
-    }
-}
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index f5dbd203b..1b8997ecf 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -219,36 +219,6 @@ mod tests {
     }
 
     #[test]
-    fn dont_complete_values_in_type_pos() {
-        check(
-            r#"
-const FOO: () = ();
-static BAR: () = ();
-struct Baz;
-fn foo() {
-    let _: self::$0;
-}
-"#,
-            expect![[r#"
-                st Baz
-            "#]],
-        );
-    }
-
-    #[test]
-    fn dont_complete_enum_variants_in_type_pos() {
-        check(
-            r#"
-enum Foo { Bar }
-fn foo() {
-    let _: Foo::$0;
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
     fn dont_complete_primitive_in_use() {
         check_builtin(r#"use self::$0;"#, expect![[""]]);
     }
@@ -259,32 +229,6 @@ fn foo() {
     }
 
     #[test]
-    fn completes_primitives() {
-        check_builtin(
-            r#"fn main() { let _: $0 = 92; }"#,
-            expect![[r#"
-                bt u32
-                bt bool
-                bt u8
-                bt isize
-                bt u16
-                bt u64
-                bt u128
-                bt f32
-                bt i128
-                bt i16
-                bt str
-                bt i64
-                bt char
-                bt f64
-                bt i32
-                bt i8
-                bt usize
-            "#]],
-        );
-    }
-
-    #[test]
     fn completes_enum_variant() {
         check(
             r#"
@@ -749,24 +693,4 @@ fn main() {
             "#]],
         );
     }
-
-    #[test]
-    fn completes_types_and_const_in_arg_list() {
-        check(
-            r#"
-mod foo {
-    pub const CONST: () = ();
-    pub type Type = ();
-}
-
-struct Foo<T>(t);
-
-fn foo(_: Foo<foo::$0>) {}
-"#,
-            expect![[r#"
-                ta Type
-                ct CONST
-            "#]],
-        );
-    }
 }
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 81c4fb305..380c1e079 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -113,78 +113,6 @@ mod tests {
     }
 
     #[test]
-    fn dont_complete_values_in_type_pos() {
-        check(
-            r#"
-const FOO: () = ();
-static BAR: () = ();
-enum Foo {
-    Bar
-}
-struct Baz;
-fn foo() {
-    let local = ();
-    let _: $0;
-}
-"#,
-            expect![[r#"
-                en Foo
-                st Baz
-            "#]],
-        );
-    }
-
-    #[test]
-    fn bind_pat_and_path_ignore_at() {
-        check(
-            r#"
-enum Enum { A, B }
-fn quux(x: Option<Enum>) {
-    match x {
-        None => (),
-        Some(en$0 @ Enum::A) => (),
-    }
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn bind_pat_and_path_ignore_ref() {
-        check(
-            r#"
-enum Enum { A, B }
-fn quux(x: Option<Enum>) {
-    match x {
-        None => (),
-        Some(ref en$0) => (),
-    }
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn bind_pat_and_path() {
-        check(
-            r#"
-enum Enum { A, B }
-fn quux(x: Option<Enum>) {
-    match x {
-        None => (),
-        Some(En$0) => (),
-    }
-}
-"#,
-            expect![[r#"
-                en Enum
-            "#]],
-        );
-    }
-
-    #[test]
     fn completes_bindings_from_let() {
         check(
             r#"
@@ -289,29 +217,6 @@ fn main() {
     }
 
     #[test]
-    fn completes_generic_params_in_struct() {
-        check(
-            r#"struct S<T> { x: $0}"#,
-            expect![[r#"
-                sp Self
-                tp T
-                st S<…>
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_self_in_enum() {
-        check(
-            r#"enum X { Y($0) }"#,
-            expect![[r#"
-                sp Self
-                en X
-            "#]],
-        );
-    }
-
-    #[test]
     fn completes_module_items() {
         check(
             r#"
@@ -365,19 +270,6 @@ mod m {
     }
 
     #[test]
-    fn completes_return_type() {
-        check(
-            r#"
-struct Foo;
-fn x() -> $0
-"#,
-            expect![[r#"
-                st Foo
-            "#]],
-        );
-    }
-
-    #[test]
     fn dont_show_both_completions_for_shadowing() {
         check(
             r#"
@@ -559,19 +451,6 @@ fn foo() { $0 }
     }
 
     #[test]
-    fn completes_macros_as_type() {
-        check(
-            r#"
-macro_rules! foo { () => {} }
-fn main() { let x: $0 }
-"#,
-            expect![[r#"
-                ma foo!(…) macro_rules! foo
-            "#]],
-        );
-    }
-
-    #[test]
     fn completes_macros_as_stmt() {
         check(
             r#"
@@ -716,30 +595,4 @@ fn f() {}
             expect![[""]],
         )
     }
-
-    #[test]
-    fn completes_types_and_const_in_arg_list() {
-        check(
-            r#"
-enum Bar {
-    Baz
-}
-trait Foo {
-    type Bar;
-}
-
-const CONST: () = ();
-
-fn foo<T: Foo<$0>, const CONST_PARAM: usize>(_: T) {}
-"#,
-            expect![[r#"
-                ta Bar =       type Bar;
-                tp T
-                cp CONST_PARAM
-                tt Foo
-                en Bar
-                ct CONST
-            "#]],
-        );
-    }
 }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index e49e434fa..f0da98739 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -286,8 +286,11 @@ impl<'a> CompletionContext<'a> {
         )
     }
 
-    pub(crate) fn expect_record_field(&self) -> bool {
-        matches!(self.completion_location, Some(ImmediateLocation::RecordField))
+    pub(crate) fn expect_field(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::RecordField | ImmediateLocation::TupleField)
+        )
     }
 
     pub(crate) fn in_use_tree(&self) -> bool {
@@ -385,14 +388,19 @@ impl<'a> CompletionContext<'a> {
                         (ty, name)
                     },
                     ast::ArgList(_it) => {
-                        cov_mark::hit!(expected_type_fn_param_with_leading_char);
-                        cov_mark::hit!(expected_type_fn_param_without_leading_char);
+                        cov_mark::hit!(expected_type_fn_param);
                         ActiveParameter::at_token(
                             &self.sema,
                             self.token.clone(),
                         ).map(|ap| {
                             let name = ap.ident().map(NameOrNameRef::Name);
-                            (Some(ap.ty), name)
+                            let ty = if has_ref(&self.token) {
+                                cov_mark::hit!(expected_type_fn_param_ref);
+                                ap.ty.remove_ref()
+                            } else {
+                                Some(ap.ty)
+                            };
+                            (ty, name)
                         })
                         .unwrap_or((None, None))
                     },
@@ -697,6 +705,19 @@ fn path_or_use_tree_qualifier(path: &ast::Path) -> Option<(ast::Path, bool)> {
     use_tree.path().zip(Some(true))
 }
 
+fn has_ref(token: &SyntaxToken) -> bool {
+    let mut token = token.clone();
+    for skip in [WHITESPACE, IDENT, T![mut]] {
+        if token.kind() == skip {
+            token = match token.prev_token() {
+                Some(it) => it,
+                None => return false,
+            }
+        }
+    }
+    token.kind() == T![&]
+}
+
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
@@ -769,14 +790,18 @@ fn foo() {
     }
 
     #[test]
-    fn expected_type_fn_param_without_leading_char() {
-        cov_mark::check!(expected_type_fn_param_without_leading_char);
+    fn expected_type_fn_param() {
+        cov_mark::check!(expected_type_fn_param);
         check_expected_type_and_name(
             r#"
-fn foo() {
-    bar($0);
-}
-
+fn foo() { bar($0); }
+fn bar(x: u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(c$0); }
 fn bar(x: u32) {}
 "#,
             expect![[r#"ty: u32, name: x"#]],
@@ -784,18 +809,29 @@ fn bar(x: u32) {}
     }
 
     #[test]
-    fn expected_type_fn_param_with_leading_char() {
-        cov_mark::check!(expected_type_fn_param_with_leading_char);
+    fn expected_type_fn_param_ref() {
+        cov_mark::check!(expected_type_fn_param_ref);
         check_expected_type_and_name(
             r#"
-fn foo() {
-    bar(c$0);
-}
-
-fn bar(x: u32) {}
+fn foo() { bar(&$0); }
+fn bar(x: &u32) {}
 "#,
             expect![[r#"ty: u32, name: x"#]],
         );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(&mut $0); }
+fn bar(x: &mut u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(&c$0); }
+fn bar(x: &u32) {}
+        "#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
     }
 
     #[test]
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index 271409c38..757c9a3da 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -31,6 +31,7 @@ pub(crate) enum ImmediateLocation {
     Impl,
     Trait,
     RecordField,
+    TupleField,
     RefExpr,
     IdentPat,
     BlockExpr,
@@ -187,7 +188,13 @@ pub(crate) fn determine_location(
             ast::SourceFile(_it) => ImmediateLocation::ItemList,
             ast::ItemList(_it) => ImmediateLocation::ItemList,
             ast::RefExpr(_it) => ImmediateLocation::RefExpr,
-            ast::RecordField(_it) => ImmediateLocation::RecordField,
+            ast::RecordField(it) => if it.ty().map_or(false, |it| it.syntax().text_range().contains(offset)) {
+                return None;
+            } else {
+                ImmediateLocation::RecordField
+            },
+            ast::TupleField(_it) => ImmediateLocation::TupleField,
+            ast::TupleFieldList(_it) => ImmediateLocation::TupleField,
             ast::AssocItemList(it) => match it.syntax().parent().map(|it| it.kind()) {
                 Some(IMPL) => ImmediateLocation::Impl,
                 Some(TRAIT) => ImmediateLocation::Trait,
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 9bec03e17..1a9b6212a 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -1057,7 +1057,7 @@ fn f() {
     #[test]
     fn suggest_ref_mut() {
         cov_mark::check!(suggest_ref);
-        check(
+        check_relevance(
             r#"
 struct S;
 fn foo(s: &mut S) {}
@@ -1067,58 +1067,29 @@ fn main() {
 }
             "#,
             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: "fn(&mut S)",
-                        trigger_call_info: true,
-                    },
-                    CompletionItem {
-                        label: "main()",
-                        source_range: 70..70,
-                        delete: 70..70,
-                        insert: "main()$0",
-                        kind: SymbolKind(
-                            Function,
-                        ),
-                        lookup: "main",
-                        detail: "fn()",
-                    },
-                    CompletionItem {
-                        label: "s",
-                        source_range: 70..70,
-                        delete: 70..70,
-                        insert: "s",
-                        kind: SymbolKind(
-                            Local,
-                        ),
-                        detail: "S",
-                        relevance: CompletionRelevance {
-                            exact_name_match: true,
-                            type_match: None,
-                            is_local: true,
-                        },
-                        ref_match: "&mut ",
-                    },
-                ]
+                lc s [name+local]
+                lc &mut s [type+name+local]
+                st S []
+                fn main() []
+                fn foo(…) []
             "#]],
-        )
+        );
+        check_relevance(
+            r#"
+struct S;
+fn foo(s: &mut S) {}
+fn main() {
+    let mut s = S;
+    foo(&mut $0);
+}
+            "#,
+            expect![[r#"
+                lc s [type+name+local]
+                st S []
+                fn main() []
+                fn foo(…) []
+            "#]],
+        );
     }
 
     #[test]
diff --git a/crates/ide_completion/src/tests.rs b/crates/ide_completion/src/tests.rs
index 211c89c40..97298ff27 100644
--- a/crates/ide_completion/src/tests.rs
+++ b/crates/ide_completion/src/tests.rs
@@ -7,6 +7,10 @@
 mod item_list;
 mod use_tree;
 mod items;
+mod pattern;
+mod type_pos;
+
+use std::mem;
 
 use hir::{PrefixKind, Semantics};
 use ide_db::{
@@ -45,7 +49,16 @@ pub(crate) fn completion_list(code: &str) -> String {
 }
 
 fn completion_list_with_config(config: CompletionConfig, code: &str) -> String {
-    render_completion_list(get_all_items(config, code))
+    // filter out all but one builtintype completion for smaller test outputs
+    let items = get_all_items(config, code);
+    let mut bt_seen = false;
+    let items = items
+        .into_iter()
+        .filter(|it| {
+            it.completion_kind != CompletionKind::BuiltinType || !mem::replace(&mut bt_seen, true)
+        })
+        .collect();
+    render_completion_list(items)
 }
 
 /// Creates analysis from a multi-file fixture, returns positions marked with $0.
diff --git a/crates/ide_completion/src/tests/items.rs b/crates/ide_completion/src/tests/items.rs
index 8dfb8221b..b98baffd6 100644
--- a/crates/ide_completion/src/tests/items.rs
+++ b/crates/ide_completion/src/tests/items.rs
@@ -35,22 +35,6 @@ impl Tra$0
             ma foo!(…) #[macro_export] macro_rules! foo
             ma foo!(…) #[macro_export] macro_rules! foo
             bt u32
-            bt bool
-            bt u8
-            bt isize
-            bt u16
-            bt u64
-            bt u128
-            bt f32
-            bt i128
-            bt i16
-            bt str
-            bt i64
-            bt char
-            bt f64
-            bt i32
-            bt i8
-            bt usize
         "##]],
     )
 }
@@ -69,22 +53,6 @@ impl Trait for Str$0
             ma foo!(…) #[macro_export] macro_rules! foo
             ma foo!(…) #[macro_export] macro_rules! foo
             bt u32
-            bt bool
-            bt u8
-            bt isize
-            bt u16
-            bt u64
-            bt u128
-            bt f32
-            bt i128
-            bt i16
-            bt str
-            bt i64
-            bt char
-            bt f64
-            bt i32
-            bt i8
-            bt usize
         "##]],
     )
 }
diff --git a/crates/ide_completion/src/tests/pattern.rs b/crates/ide_completion/src/tests/pattern.rs
new file mode 100644
index 000000000..1ad5ccd97
--- /dev/null
+++ b/crates/ide_completion/src/tests/pattern.rs
@@ -0,0 +1,348 @@
+//! Completions tests for pattern position.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = completion_list(ra_fixture);
+    expect.assert_eq(&actual)
+}
+
+fn check_with(ra_fixture: &str, expect: Expect) {
+    let base = r#"
+enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV }
+use self::Enum::TupleV;
+mod module {}
+
+static STATIC: Unit = Unit;
+const CONST: Unit = Unit;
+struct Record { field: u32 }
+struct Tuple(u32);
+struct Unit
+macro_rules! makro {}
+"#;
+    let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn ident_rebind_pat() {
+    check(
+        r#"
+fn quux() {
+    let en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ident_ref_pat() {
+    check(
+        r#"
+fn quux() {
+    let ref en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    check(
+        r#"
+fn quux() {
+    let ref en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ident_ref_mut_pat() {
+    // FIXME mut is already here, don't complete it again
+    check(
+        r#"
+fn quux() {
+    let ref mut en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    check(
+        r#"
+fn quux() {
+    let ref mut en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ref_pat() {
+    check(
+        r#"
+fn quux() {
+    let &en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    // FIXME mut is already here, don't complete it again
+    check(
+        r#"
+fn quux() {
+    let &mut en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn refutable() {
+    check_with(
+        r#"
+fn foo() {
+    if let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }$0
+            st Record
+            en Enum
+            bn Tuple     Tuple($1)$0
+            st Tuple
+            md module
+            bn TupleV    TupleV($1)$0
+            ev TupleV
+            st Unit
+            ct CONST
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn irrefutable() {
+    check_with(
+        r#"
+fn foo() {
+   let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }$0
+            st Record
+            bn Tuple     Tuple($1)$0
+            st Tuple
+            st Unit
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn in_param() {
+    check_with(
+        r#"
+fn foo(a$0) {
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }: Record$0
+            st Record
+            bn Tuple     Tuple($1): Tuple$0
+            st Tuple
+            st Unit
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn only_fn_like_macros() {
+    check(
+        r#"
+macro_rules! m { ($e:expr) => { $e } }
+
+#[rustc_builtin_macro]
+macro Clone {}
+
+fn foo() {
+    let x$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            ma m!(…) macro_rules! m
+        "#]],
+    );
+}
+
+#[test]
+fn in_simple_macro_call() {
+    check(
+        r#"
+macro_rules! m { ($e:expr) => { $e } }
+enum E { X }
+
+fn foo() {
+   m!(match E::X { a$0 })
+}
+"#,
+        expect![[r#"
+            kw mut
+            ev E::X  ()
+            en E
+            ma m!(…) macro_rules! m
+        "#]],
+    );
+}
+
+#[test]
+fn omits_private_fields_pat() {
+    check(
+        r#"
+mod foo {
+    pub struct Record { pub field: i32, _field: i32 }
+    pub struct Tuple(pub u32, u32);
+    pub struct Invisible(u32, u32);
+}
+use foo::*;
+
+fn outer() {
+    if let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1, .. }$0
+            st Record
+            bn Tuple     Tuple($1, ..)$0
+            st Tuple
+            st Invisible
+            md foo
+        "#]],
+    )
+}
+
+// #[test]
+// fn only_shows_ident_completion() {
+//     check_edit(
+//         "Foo",
+//         r#"
+// struct Foo(i32);
+// fn main() {
+//     match Foo(92) {
+//         a$0(92) => (),
+//     }
+// }
+// "#,
+//         r#"
+// struct Foo(i32);
+// fn main() {
+//     match Foo(92) {
+//         Foo(92) => (),
+//     }
+// }
+// "#,
+//     );
+// }
+
+#[test]
+fn completes_self_pats() {
+    check(
+        r#"
+struct Foo(i32);
+impl Foo {
+    fn foo() {
+        match Foo(0) {
+            a$0
+        }
+    }
+}
+    "#,
+        expect![[r#"
+            kw mut
+            bn Self Self($1)$0
+            sp Self
+            bn Foo  Foo($1)$0
+            st Foo
+        "#]],
+    )
+}
+
+#[test]
+fn completes_qualified_variant() {
+    check(
+        r#"
+enum Foo {
+    Bar { baz: i32 }
+}
+impl Foo {
+    fn foo() {
+        match {Foo::Bar { baz: 0 }} {
+            B$0
+        }
+    }
+}
+    "#,
+        expect![[r#"
+            kw mut
+            bn Self::Bar Self::Bar { baz$1 }$0
+            ev Self::Bar { baz: i32 }
+            bn Foo::Bar  Foo::Bar { baz$1 }$0
+            ev Foo::Bar  { baz: i32 }
+            sp Self
+            en Foo
+        "#]],
+    )
+}
+
+#[test]
+fn completes_in_record_field_pat() {
+    check(
+        r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar: $0 }: Foo) {}
+"#,
+        expect![[r#"
+            kw mut
+            bn Foo Foo { bar$1 }$0
+            st Foo
+            bn Bar Bar($1)$0
+            st Bar
+        "#]],
+    )
+}
+
+#[test]
+fn skips_in_record_field_pat_name() {
+    check(
+        r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar$0 }: Foo) {}
+"#,
+        expect![[r#""#]],
+    )
+}
diff --git a/crates/ide_completion/src/tests/type_pos.rs b/crates/ide_completion/src/tests/type_pos.rs
new file mode 100644
index 000000000..1ab47b27e
--- /dev/null
+++ b/crates/ide_completion/src/tests/type_pos.rs
@@ -0,0 +1,177 @@
+//! Completions tests for type position.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check_with(ra_fixture: &str, expect: Expect) {
+    let base = r#"
+enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV }
+use self::Enum::TupleV;
+mod module {}
+
+trait Trait {}
+static STATIC: Unit = Unit;
+const CONST: Unit = Unit;
+struct Record { field: u32 }
+struct Tuple(u32);
+struct Unit
+macro_rules! makro {}
+"#;
+    let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn record_field_ty() {
+    check_with(
+        r#"
+struct Foo<'lt, T, const C: usize> {
+    f: $0
+}
+"#,
+        expect![[r#"
+            sp Self
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Foo<…>
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn tuple_struct_field() {
+    check_with(
+        r#"
+struct Foo<'lt, T, const C: usize>(f$0);
+"#,
+        expect![[r#"
+            kw pub(crate)
+            kw pub
+            sp Self
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Foo<…>
+            st Unit
+            ma makro!(…)  macro_rules! makro
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn fn_return_type() {
+    check_with(
+        r#"
+fn x<'lt, T, const C: usize>() -> $0
+"#,
+        expect![[r#"
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    );
+}
+
+#[test]
+fn body_type_pos() {
+    check_with(
+        r#"
+fn foo<'lt, T, const C: usize>() {
+    let local = ();
+    let _: $0;
+}
+"#,
+        expect![[r#"
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    );
+    check_with(
+        r#"
+fn foo<'lt, T, const C: usize>() {
+    let local = ();
+    let _: self::$0;
+}
+"#,
+        expect![[r#"
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+        "#]],
+    );
+}
+
+#[test]
+fn completes_types_and_const_in_arg_list() {
+    // FIXME: we should complete the lifetime here for now
+    check_with(
+        r#"
+trait Trait2 {
+    type Foo;
+}
+
+fn foo<'lt, T: Trait2<$0>, const CONST_PARAM: usize>(_: T) {}
+"#,
+        expect![[r#"
+            ta Foo =       type Foo;
+            tp T
+            cp CONST_PARAM
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            tt Trait2
+            md module
+            st Unit
+            ct CONST
+            ma makro!(…)   macro_rules! makro
+            bt u32
+        "#]],
+    );
+    check_with(
+        r#"
+trait Trait2 {
+    type Foo;
+}
+
+fn foo<'lt, T: Trait2<self::$0>, const CONST_PARAM: usize>(_: T) {}
+    "#,
+        expect![[r#"
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            tt Trait2
+            md module
+            st Unit
+            ct CONST
+        "#]],
+    );
+}
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index b4f2fe9a4..0d694b1a7 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -645,7 +645,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
                     None if match_res.err.is_none() => {
                         bindings_builder.push_optional(&mut item.bindings, name);
                     }
-                    _ => {}
+                    None => {}
                 }
                 if let Some(err) = match_res.err {
                     res.add_err(err);
@@ -756,7 +756,7 @@ impl<'a> TtIter<'a> {
         let ok = match separator {
             Separator::Ident(lhs) if idx == 0 => match fork.expect_ident_or_underscore() {
                 Ok(rhs) => rhs.text == lhs.text,
-                _ => false,
+                Err(_) => false,
             },
             Separator::Literal(lhs) if idx == 0 => match fork.expect_literal() {
                 Ok(rhs) => match rhs {
@@ -764,11 +764,11 @@ impl<'a> TtIter<'a> {
                     tt::Leaf::Ident(rhs) => rhs.text == lhs.text,
                     tt::Leaf::Punct(_) => false,
                 },
-                _ => false,
+                Err(_) => false,
             },
             Separator::Puncts(lhss) if idx < lhss.len() => match fork.expect_punct() {
                 Ok(rhs) => rhs.char == lhss[idx].char,
-                _ => false,
+                Err(_) => false,
             },
             _ => false,
         };
diff --git a/crates/mbe/src/expander/transcriber.rs b/crates/mbe/src/expander/transcriber.rs
index 49a137577..4894e2a0c 100644
--- a/crates/mbe/src/expander/transcriber.rs
+++ b/crates/mbe/src/expander/transcriber.rs
@@ -241,6 +241,6 @@ fn push_fragment(buf: &mut Vec<tt::TokenTree>, fragment: Fragment) {
 fn push_subtree(buf: &mut Vec<tt::TokenTree>, tt: tt::Subtree) {
     match tt.delimiter {
         None => buf.extend(tt.token_trees),
-        _ => buf.push(tt.into()),
+        Some(_) => buf.push(tt.into()),
     }
 }
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 8c8528aaf..fcc596756 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -135,7 +135,7 @@ impl Shift {
 
     /// Shift given TokenTree token id
     fn shift_all(self, tt: &mut tt::Subtree) {
-        for t in tt.token_trees.iter_mut() {
+        for t in &mut tt.token_trees {
             match t {
                 tt::TokenTree::Leaf(leaf) => match leaf {
                     tt::Leaf::Ident(ident) => ident.id = self.shift(ident.id),
@@ -188,7 +188,7 @@ impl MacroRules {
             }
         }
 
-        for rule in rules.iter() {
+        for rule in &rules {
             validate(&rule.lhs)?;
         }
 
@@ -241,7 +241,7 @@ impl MacroDef {
             }
             rules.push(rule);
         }
-        for rule in rules.iter() {
+        for rule in &rules {
             validate(&rule.lhs)?;
         }
 
@@ -268,7 +268,7 @@ impl MacroDef {
 }
 
 impl Rule {
-    fn parse(src: &mut TtIter, expect_arrow: bool) -> Result<Rule, ParseError> {
+    fn parse(src: &mut TtIter, expect_arrow: bool) -> Result<Self, ParseError> {
         let lhs = src
             .expect_subtree()
             .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
@@ -356,7 +356,7 @@ impl<T> ExpandResult<T> {
     }
 
     pub fn result(self) -> Result<T, ExpandError> {
-        self.err.map(Err).unwrap_or(Ok(self.value))
+        self.err.map_or(Ok(self.value), Err)
     }
 }
 
diff --git a/crates/mbe/src/subtree_source.rs b/crates/mbe/src/subtree_source.rs
index ee80807ad..ffc2a6017 100644
--- a/crates/mbe/src/subtree_source.rs
+++ b/crates/mbe/src/subtree_source.rs
@@ -115,7 +115,7 @@ impl<'a> TokenSource for SubtreeTokenSource {
     fn is_keyword(&self, kw: &str) -> bool {
         match self.cached.get(self.curr.1) {
             Some(t) => t.text == *kw,
-            _ => false,
+            None => false,
         }
     }
 }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index cdc22425d..7526bd8e6 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -283,7 +283,7 @@ trait TokenConvertor {
                 let (id, idx) = self.id_alloc().open_delim(range);
                 subtree.delimiter = Some(tt::Delimiter { id, kind });
 
-                while self.peek().map(|it| it.kind() != closed).unwrap_or(false) {
+                while self.peek().map_or(false, |it| it.kind() != closed) {
                     self.collect_leaf(&mut subtree.token_trees);
                 }
                 let last_range = match self.bump() {
diff --git a/crates/mbe/src/tt_iter.rs b/crates/mbe/src/tt_iter.rs
index 5a4eca7bf..65da83476 100644
--- a/crates/mbe/src/tt_iter.rs
+++ b/crates/mbe/src/tt_iter.rs
@@ -121,10 +121,11 @@ impl<'a> TtIter<'a> {
 
         parser::parse_fragment(&mut src, &mut sink, fragment_kind);
 
-        let mut err = None;
-        if !sink.cursor.is_root() || sink.error {
-            err = Some(err!("expected {:?}", fragment_kind));
-        }
+        let mut err = if !sink.cursor.is_root() || sink.error {
+            Some(err!("expected {:?}", fragment_kind))
+        } else {
+            None
+        };
 
         let mut curr = buffer.begin();
         let mut res = vec![];
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index 65ca3eb6c..e252e89a5 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -248,7 +248,7 @@ pub mod token_stream {
             token_trees: subtree
                 .token_trees
                 .into_iter()
-                .map(|t| token_tree_replace_token_ids_with_unspecified(t))
+                .map(token_tree_replace_token_ids_with_unspecified)
                 .collect(),
         }
     }
@@ -457,7 +457,7 @@ impl server::Group for Rustc {
     }
 
     fn span(&mut self, group: &Self::Group) -> Self::Span {
-        group.delimiter.map(|it| it.id).unwrap_or_else(|| tt::TokenId::unspecified())
+        group.delimiter.map(|it| it.id).unwrap_or_else(tt::TokenId::unspecified)
     }
 
     fn set_span(&mut self, _group: &mut Self::Group, _span: Self::Span) {
diff --git a/crates/proc_macro_test/build.rs b/crates/proc_macro_test/build.rs
index 4653a93dd..1e7aa026f 100644
--- a/crates/proc_macro_test/build.rs
+++ b/crates/proc_macro_test/build.rs
@@ -17,9 +17,16 @@ fn main() {
 
     let name = "proc_macro_test_impl";
     let version = "0.0.0";
+    let target_dir = out_dir.join("target");
     let output = Command::new(toolchain::cargo())
         .current_dir("imp")
         .args(&["build", "-p", "proc_macro_test_impl", "--message-format", "json"])
+        // Explicit override the target directory to avoid using the same one which the parent
+        // cargo is using, or we'll deadlock.
+        // This can happen when `CARGO_TARGET_DIR` is set or global config forces all cargo
+        // instance to use the same target directory.
+        .arg("--target-dir")
+        .arg(&target_dir)
         .output()
         .unwrap();
     assert!(output.status.success());
@@ -39,10 +46,9 @@ fn main() {
         }
     }
 
-    let src_path = artifact_path.expect("no dylib for proc_macro_test_impl found");
-    let dest_path = out_dir.join(src_path.file_name().unwrap());
-    fs::copy(src_path, &dest_path).unwrap();
+    // This file is under `target_dir` and is already under `OUT_DIR`.
+    let artifact_path = artifact_path.expect("no dylib for proc_macro_test_impl found");
 
     let info_path = out_dir.join("proc_macro_test_location.txt");
-    fs::write(info_path, dest_path.to_str().unwrap()).unwrap();
+    fs::write(info_path, artifact_path.to_str().unwrap()).unwrap();
 }
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index ac079f83e..0935ea967 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -1,5 +1,6 @@
 //! See [`CargoWorkspace`].
 
+use std::iter;
 use std::path::PathBuf;
 use std::{convert::TryInto, ops, process::Command, sync::Arc};
 
@@ -12,6 +13,7 @@ use rustc_hash::FxHashMap;
 use serde::Deserialize;
 use serde_json::from_value;
 
+use crate::CfgOverrides;
 use crate::{build_data::BuildDataConfig, utf8_stdout};
 
 /// [`CargoWorkspace`] represents the logical structure of, well, a Cargo
@@ -76,6 +78,21 @@ pub struct CargoConfig {
 
     /// rustc private crate source
     pub rustc_source: Option<RustcSource>,
+
+    /// crates to disable `#[cfg(test)]` on
+    pub unset_test_crates: Vec<String>,
+}
+
+impl CargoConfig {
+    pub fn cfg_overrides(&self) -> CfgOverrides {
+        self.unset_test_crates
+            .iter()
+            .cloned()
+            .zip(iter::repeat_with(|| {
+                cfg::CfgDiff::new(Vec::new(), vec![cfg::CfgAtom::Flag("test".into())]).unwrap()
+            }))
+            .collect()
+    }
 }
 
 pub type Package = Idx<PackageData>;
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index 8c6cf94c2..1d408dff2 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -41,7 +41,7 @@ pub use crate::{
     },
     project_json::{ProjectJson, ProjectJsonData},
     sysroot::Sysroot,
-    workspace::{PackageRoot, ProjectWorkspace},
+    workspace::{CfgOverrides, PackageRoot, ProjectWorkspace},
 };
 
 pub use proc_macro_api::ProcMacroClient;
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index a22f79c15..006263da8 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -68,8 +68,9 @@ impl Sysroot {
     pub fn load(sysroot_src_dir: &AbsPath) -> Result<Sysroot> {
         let mut sysroot = Sysroot { crates: Arena::default() };
 
-        for name in SYSROOT_CRATES.trim().lines() {
-            let root = [format!("{}/src/lib.rs", name), format!("lib{}/lib.rs", name)]
+        for path in SYSROOT_CRATES.trim().lines() {
+            let name = path.split('/').last().unwrap();
+            let root = [format!("{}/src/lib.rs", path), format!("lib{}/lib.rs", path)]
                 .iter()
                 .map(|it| sysroot_src_dir.join(it))
                 .find(|it| it.exists());
@@ -191,9 +192,8 @@ panic_abort
 panic_unwind
 proc_macro
 profiler_builtins
-rtstartup
 std
-stdarch
+stdarch/crates/std_detect
 term
 test
 unwind";
@@ -204,9 +204,8 @@ core
 panic_abort
 panic_unwind
 profiler_builtins
-rtstartup
 proc_macro
-stdarch
+std_detect
 term
 test
 unwind";
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index ef0f3c9e4..e67ba2bd9 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -7,7 +7,7 @@ use std::{collections::VecDeque, fmt, fs, path::Path, process::Command};
 use anyhow::{format_err, Context, Result};
 use base_db::{CrateDisplayName, CrateGraph, CrateId, CrateName, Edition, Env, FileId, ProcMacro};
 use cargo_workspace::DepKind;
-use cfg::CfgOptions;
+use cfg::{CfgDiff, CfgOptions};
 use paths::{AbsPath, AbsPathBuf};
 use proc_macro_api::ProcMacroClient;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -22,6 +22,8 @@ use crate::{
     Sysroot, TargetKind,
 };
 
+pub type CfgOverrides = FxHashMap<String, CfgDiff>;
+
 /// `PackageRoot` describes a package root folder.
 /// Which may be an external dependency, or a member of
 /// the current workspace.
@@ -46,6 +48,7 @@ pub enum ProjectWorkspace {
         /// FIXME: make this a per-crate map, as, eg, build.rs might have a
         /// different target.
         rustc_cfg: Vec<CfgFlag>,
+        cfg_overrides: CfgOverrides,
     },
     /// Project workspace was manually specified using a `rust-project.json` file.
     Json { project: ProjectJson, sysroot: Option<Sysroot>, rustc_cfg: Vec<CfgFlag> },
@@ -67,7 +70,7 @@ impl fmt::Debug for ProjectWorkspace {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Make sure this isn't too verbose.
         match self {
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg } => f
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg, cfg_overrides } => f
                 .debug_struct("Cargo")
                 .field("root", &cargo.workspace_root().file_name())
                 .field("n_packages", &cargo.packages().len())
@@ -77,6 +80,7 @@ impl fmt::Debug for ProjectWorkspace {
                     &rustc.as_ref().map_or(0, |rc| rc.packages().len()),
                 )
                 .field("n_rustc_cfg", &rustc_cfg.len())
+                .field("n_cfg_overrides", &cfg_overrides.len())
                 .finish(),
             ProjectWorkspace::Json { project, sysroot, rustc_cfg } => {
                 let mut debug_struct = f.debug_struct("Json");
@@ -164,7 +168,9 @@ impl ProjectWorkspace {
                 };
 
                 let rustc_cfg = rustc_cfg::get(Some(&cargo_toml), config.target.as_deref());
-                ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg }
+
+                let cfg_overrides = config.cfg_overrides();
+                ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg, cfg_overrides }
             }
         };
 
@@ -213,43 +219,45 @@ impl ProjectWorkspace {
                     })
                 }))
                 .collect::<Vec<_>>(),
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg: _ } => cargo
-                .packages()
-                .map(|pkg| {
-                    let is_member = cargo[pkg].is_member;
-                    let pkg_root = cargo[pkg].root().to_path_buf();
-
-                    let mut include = vec![pkg_root.clone()];
-                    include.extend(
-                        build_data
-                            .and_then(|it| it.get(cargo.workspace_root()))
-                            .and_then(|map| map.get(&cargo[pkg].id))
-                            .and_then(|it| it.out_dir.clone()),
-                    );
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg: _, cfg_overrides: _ } => {
+                cargo
+                    .packages()
+                    .map(|pkg| {
+                        let is_member = cargo[pkg].is_member;
+                        let pkg_root = cargo[pkg].root().to_path_buf();
+
+                        let mut include = vec![pkg_root.clone()];
+                        include.extend(
+                            build_data
+                                .and_then(|it| it.get(cargo.workspace_root()))
+                                .and_then(|map| map.get(&cargo[pkg].id))
+                                .and_then(|it| it.out_dir.clone()),
+                        );
 
-                    let mut exclude = vec![pkg_root.join(".git")];
-                    if is_member {
-                        exclude.push(pkg_root.join("target"));
-                    } else {
-                        exclude.push(pkg_root.join("tests"));
-                        exclude.push(pkg_root.join("examples"));
-                        exclude.push(pkg_root.join("benches"));
-                    }
-                    PackageRoot { is_member, include, exclude }
-                })
-                .chain(sysroot.crates().map(|krate| PackageRoot {
-                    is_member: false,
-                    include: vec![sysroot[krate].root_dir().to_path_buf()],
-                    exclude: Vec::new(),
-                }))
-                .chain(rustc.into_iter().flat_map(|rustc| {
-                    rustc.packages().map(move |krate| PackageRoot {
+                        let mut exclude = vec![pkg_root.join(".git")];
+                        if is_member {
+                            exclude.push(pkg_root.join("target"));
+                        } else {
+                            exclude.push(pkg_root.join("tests"));
+                            exclude.push(pkg_root.join("examples"));
+                            exclude.push(pkg_root.join("benches"));
+                        }
+                        PackageRoot { is_member, include, exclude }
+                    })
+                    .chain(sysroot.crates().map(|krate| PackageRoot {
                         is_member: false,
-                        include: vec![rustc[krate].root().to_path_buf()],
+                        include: vec![sysroot[krate].root_dir().to_path_buf()],
                         exclude: Vec::new(),
-                    })
-                }))
-                .collect(),
+                    }))
+                    .chain(rustc.into_iter().flat_map(|rustc| {
+                        rustc.packages().map(move |krate| PackageRoot {
+                            is_member: false,
+                            include: vec![rustc[krate].root().to_path_buf()],
+                            exclude: Vec::new(),
+                        })
+                    }))
+                    .collect()
+            }
             ProjectWorkspace::DetachedFiles { files, sysroot, .. } => files
                 .into_iter()
                 .map(|detached_file| PackageRoot {
@@ -299,16 +307,22 @@ impl ProjectWorkspace {
                 project,
                 sysroot,
             ),
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg } => cargo_to_crate_graph(
-                rustc_cfg.clone(),
-                &proc_macro_loader,
-                load,
-                cargo,
-                build_data.and_then(|it| it.get(cargo.workspace_root())),
-                sysroot,
-                rustc,
-                rustc.as_ref().zip(build_data).and_then(|(it, map)| map.get(it.workspace_root())),
-            ),
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg, cfg_overrides } => {
+                cargo_to_crate_graph(
+                    rustc_cfg.clone(),
+                    cfg_overrides,
+                    &proc_macro_loader,
+                    load,
+                    cargo,
+                    build_data.and_then(|it| it.get(cargo.workspace_root())),
+                    sysroot,
+                    rustc,
+                    rustc
+                        .as_ref()
+                        .zip(build_data)
+                        .and_then(|(it, map)| map.get(it.workspace_root())),
+                )
+            }
             ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => {
                 detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot)
             }
@@ -370,6 +384,7 @@ fn project_json_to_crate_graph(
                     file_id,
                     krate.edition,
                     krate.display_name.clone(),
+                    cfg_options.clone(),
                     cfg_options,
                     env,
                     proc_macro.unwrap_or_default(),
@@ -398,6 +413,7 @@ fn project_json_to_crate_graph(
 
 fn cargo_to_crate_graph(
     rustc_cfg: Vec<CfgFlag>,
+    override_cfg: &CfgOverrides,
     proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     cargo: &CargoWorkspace,
@@ -425,6 +441,21 @@ fn cargo_to_crate_graph(
     let mut has_private = false;
     // Next, create crates for each package, target pair
     for pkg in cargo.packages() {
+        let mut cfg_options = &cfg_options;
+        let mut replaced_cfg_options;
+        if let Some(overrides) = override_cfg.get(&cargo[pkg].name) {
+            // FIXME: this is sort of a hack to deal with #![cfg(not(test))] vanishing such as seen
+            // in ed25519_dalek (#7243), and libcore (#9203) (although you only hit that one while
+            // working on rust-lang/rust as that's the only time it appears outside sysroot).
+            //
+            // A more ideal solution might be to reanalyze crates based on where the cursor is and
+            // figure out the set of cfgs that would have to apply to make it active.
+
+            replaced_cfg_options = cfg_options.clone();
+            replaced_cfg_options.apply_diff(overrides.clone());
+            cfg_options = &replaced_cfg_options;
+        };
+
         has_private |= cargo[pkg].metadata.rustc_private;
         let mut lib_tgt = None;
         for &tgt in cargo[pkg].targets.iter() {
@@ -550,6 +581,7 @@ fn detached_files_to_crate_graph(
             Edition::Edition2018,
             display_name,
             cfg_options.clone(),
+            cfg_options.clone(),
             Env::default(),
             Vec::new(),
         );
@@ -689,11 +721,19 @@ fn add_target_crate_root(
         .unwrap_or_default();
 
     let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_string());
+    let mut potential_cfg_options = cfg_options.clone();
+    potential_cfg_options.extend(
+        pkg.features
+            .iter()
+            .map(|feat| CfgFlag::KeyValue { key: "feature".into(), value: feat.0.into() }),
+    );
+
     let crate_id = crate_graph.add_crate_root(
         file_id,
         edition,
         Some(display_name),
         cfg_options,
+        potential_cfg_options,
         env,
         proc_macro,
     );
@@ -723,6 +763,7 @@ fn sysroot_to_crate_graph(
                 Edition::Edition2018,
                 Some(display_name),
                 cfg_options.clone(),
+                cfg_options.clone(),
                 env,
                 proc_macro,
             );
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 16c295639..b9aa6f0aa 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -10,7 +10,10 @@
 use std::{ffi::OsString, iter, path::PathBuf};
 
 use flycheck::FlycheckConfig;
-use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
+use ide::{
+    AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, HoverDocFormat,
+    InlayHintsConfig,
+};
 use ide_db::helpers::{
     insert_use::{ImportGranularity, InsertUseConfig, PrefixKind},
     SnippetCap,
@@ -32,6 +35,9 @@ use crate::{
 //
 // However, editor specific config, which the server doesn't know about, should
 // be specified directly in `package.json`.
+//
+// To deprecate an option by replacing it with another name use `new_name | `old_name` so that we keep
+// parsing the old name.
 config_data! {
     struct ConfigData {
         /// How imports should be grouped into use statements.
@@ -55,6 +61,8 @@ config_data! {
         cargo_autoreload: bool           = "true",
         /// Activate all available features (`--all-features`).
         cargo_allFeatures: bool          = "false",
+        /// Unsets `#[cfg(test)]` for the specified crates.
+        cargo_unsetTest: Vec<String>   = "[\"core\"]",
         /// List of features to activate.
         cargo_features: Vec<String>      = "[]",
         /// Run build scripts (`build.rs`) for more precise code analysis.
@@ -144,6 +152,12 @@ config_data! {
         /// their contents.
         highlighting_strings: bool = "true",
 
+        /// Whether to show documentation on hover.
+        hover_documentation: bool       = "true",
+        /// Use markdown syntax for links in hover.
+        hover_linksInHover |
+        hoverActions_linksInHover: bool = "true",
+
         /// Whether to show `Debug` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
         hoverActions_debug: bool           = "true",
@@ -161,8 +175,6 @@ config_data! {
         /// Whether to show `Run` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
         hoverActions_run: bool             = "true",
-        /// Use markdown syntax for links in hover.
-        hoverActions_linksInHover: bool    = "true",
 
         /// Whether to show inlay type hints for method chains.
         inlayHints_chainingHints: bool      = "true",
@@ -303,6 +315,37 @@ impl LensConfig {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct HoverActionsConfig {
+    pub implementations: bool,
+    pub references: bool,
+    pub run: bool,
+    pub debug: bool,
+    pub goto_type_def: bool,
+}
+
+impl HoverActionsConfig {
+    pub const NO_ACTIONS: Self = Self {
+        implementations: false,
+        references: false,
+        run: false,
+        debug: false,
+        goto_type_def: false,
+    };
+
+    pub fn any(&self) -> bool {
+        self.implementations || self.references || self.runnable() || self.goto_type_def
+    }
+
+    pub fn none(&self) -> bool {
+        !self.any()
+    }
+
+    pub fn runnable(&self) -> bool {
+        self.run || self.debug
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct FilesConfig {
     pub watcher: FilesWatcher,
@@ -521,7 +564,7 @@ impl Config {
     pub fn code_action_group(&self) -> bool {
         self.experimental("codeActionGroup")
     }
-    pub fn hover_actions(&self) -> bool {
+    pub fn experimental_hover_actions(&self) -> bool {
         self.experimental("hoverActions")
     }
     pub fn server_status_notification(&self) -> bool {
@@ -595,8 +638,10 @@ impl Config {
             target: self.data.cargo_target.clone(),
             rustc_source,
             no_sysroot: self.data.cargo_noSysroot,
+            unset_test_crates: self.data.cargo_unsetTest.clone(),
         }
     }
+
     pub fn rustfmt(&self) -> RustfmtConfig {
         match &self.data.rustfmt_overrideCommand {
             Some(args) if !args.is_empty() => {
@@ -719,30 +764,41 @@ impl Config {
             refs: self.data.lens_enable && self.data.lens_references,
         }
     }
-    pub fn highlighting_strings(&self) -> bool {
-        self.data.highlighting_strings
-    }
-    pub fn hover(&self) -> HoverConfig {
-        HoverConfig {
+    pub fn hover_actions(&self) -> HoverActionsConfig {
+        HoverActionsConfig {
             implementations: self.data.hoverActions_enable
                 && self.data.hoverActions_implementations,
             references: self.data.hoverActions_enable && self.data.hoverActions_references,
             run: self.data.hoverActions_enable && self.data.hoverActions_run,
             debug: self.data.hoverActions_enable && self.data.hoverActions_debug,
             goto_type_def: self.data.hoverActions_enable && self.data.hoverActions_gotoTypeDef,
-            links_in_hover: self.data.hoverActions_linksInHover,
-            markdown: try_or!(
-                self.caps
-                    .text_document
-                    .as_ref()?
-                    .hover
-                    .as_ref()?
-                    .content_format
-                    .as_ref()?
-                    .as_slice(),
-                &[]
-            )
-            .contains(&MarkupKind::Markdown),
+        }
+    }
+    pub fn highlighting_strings(&self) -> bool {
+        self.data.highlighting_strings
+    }
+    pub fn hover(&self) -> HoverConfig {
+        HoverConfig {
+            links_in_hover: self.data.hover_linksInHover,
+            documentation: self.data.hover_documentation.then(|| {
+                let is_markdown = try_or!(
+                    self.caps
+                        .text_document
+                        .as_ref()?
+                        .hover
+                        .as_ref()?
+                        .content_format
+                        .as_ref()?
+                        .as_slice(),
+                    &[]
+                )
+                .contains(&MarkupKind::Markdown);
+                if is_markdown {
+                    HoverDocFormat::Markdown
+                } else {
+                    HoverDocFormat::PlainText
+                }
+            }),
         }
     }
 
@@ -852,6 +908,7 @@ macro_rules! _config_data {
                     $({
                         let field = stringify!($field);
                         let ty = stringify!($ty);
+
                         (field, ty, &[$($doc),*], $default)
                     },)*
                 ])
@@ -863,6 +920,7 @@ macro_rules! _config_data {
                     $({
                         let field = stringify!($field);
                         let ty = stringify!($ty);
+
                         (field, ty, &[$($doc),*], $default)
                     },)*
                 ])
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index ccf66294f..dcead5f5c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -861,12 +861,10 @@ pub(crate) fn handle_hover(
 ) -> Result<Option<lsp_ext::Hover>> {
     let _p = profile::span("handle_hover");
     let position = from_proto::file_position(&snap, params.text_document_position_params)?;
-    let hover_config = snap.config.hover();
-    let info =
-        match snap.analysis.hover(position, hover_config.links_in_hover, hover_config.markdown)? {
-            None => return Ok(None),
-            Some(info) => info,
-        };
+    let info = match snap.analysis.hover(position, &snap.config.hover())? {
+        None => return Ok(None),
+        Some(info) => info,
+    };
     let line_index = snap.file_line_index(position.file_id)?;
     let range = to_proto::range(&line_index, info.range);
     let hover = lsp_ext::Hover {
@@ -1483,7 +1481,7 @@ fn show_impl_command_link(
     snap: &GlobalStateSnapshot,
     position: &FilePosition,
 ) -> Option<lsp_ext::CommandLinkGroup> {
-    if snap.config.hover().implementations {
+    if snap.config.hover_actions().implementations {
         if let Some(nav_data) = snap.analysis.goto_implementation(*position).unwrap_or(None) {
             let uri = to_proto::url(snap, position.file_id);
             let line_index = snap.file_line_index(position.file_id).ok()?;
@@ -1509,7 +1507,7 @@ fn show_ref_command_link(
     snap: &GlobalStateSnapshot,
     position: &FilePosition,
 ) -> Option<lsp_ext::CommandLinkGroup> {
-    if snap.config.hover().references {
+    if snap.config.hover_actions().references {
         if let Some(ref_search_res) = snap.analysis.find_all_refs(*position, None).unwrap_or(None) {
             let uri = to_proto::url(snap, position.file_id);
             let line_index = snap.file_line_index(position.file_id).ok()?;
@@ -1540,8 +1538,8 @@ fn runnable_action_links(
     runnable: Runnable,
 ) -> Option<lsp_ext::CommandLinkGroup> {
     let cargo_spec = CargoTargetSpec::for_file(snap, runnable.nav.file_id).ok()?;
-    let hover_config = snap.config.hover();
-    if !hover_config.runnable() || should_skip_target(&runnable, cargo_spec.as_ref()) {
+    let hover_actions_config = snap.config.hover_actions();
+    if !hover_actions_config.runnable() || should_skip_target(&runnable, cargo_spec.as_ref()) {
         return None;
     }
 
@@ -1549,12 +1547,12 @@ fn runnable_action_links(
     to_proto::runnable(snap, runnable).ok().map(|r| {
         let mut group = lsp_ext::CommandLinkGroup::default();
 
-        if hover_config.run {
+        if hover_actions_config.run {
             let run_command = to_proto::command::run_single(&r, action.run_title);
             group.commands.push(to_command_link(run_command, r.label.clone()));
         }
 
-        if hover_config.debug {
+        if hover_actions_config.debug {
             let dbg_command = to_proto::command::debug_single(&r);
             group.commands.push(to_command_link(dbg_command, r.label));
         }
@@ -1567,7 +1565,7 @@ fn goto_type_action_links(
     snap: &GlobalStateSnapshot,
     nav_targets: &[HoverGotoTypeData],
 ) -> Option<lsp_ext::CommandLinkGroup> {
-    if !snap.config.hover().goto_type_def || nav_targets.is_empty() {
+    if !snap.config.hover_actions().goto_type_def || nav_targets.is_empty() {
         return None;
     }
 
@@ -1587,7 +1585,7 @@ fn prepare_hover_actions(
     snap: &GlobalStateSnapshot,
     actions: &[HoverAction],
 ) -> Vec<lsp_ext::CommandLinkGroup> {
-    if snap.config.hover().none() || !snap.config.hover_actions() {
+    if snap.config.hover_actions().none() || !snap.config.experimental_hover_actions() {
         return Vec::new();
     }
 
diff --git a/crates/syntax/src/ptr.rs b/crates/syntax/src/ptr.rs
index 195d2251b..32aa69979 100644
--- a/crates/syntax/src/ptr.rs
+++ b/crates/syntax/src/ptr.rs
@@ -35,7 +35,7 @@ impl SyntaxNodePtr {
     pub fn to_node(&self, root: &SyntaxNode) -> SyntaxNode {
         assert!(root.parent().is_none());
         successors(Some(root.clone()), |node| {
-            node.children().find(|it| it.text_range().contains_range(self.range))
+            node.child_or_token_at_range(self.range).and_then(|it| it.into_node())
         })
         .find(|it| it.text_range() == self.range && it.kind() == self.kind)
         .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index d55bae62a..d9c22c180 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -11,6 +11,7 @@ mod fixture;
 mod assert_linear;
 
 use std::{
+    collections::BTreeMap,
     convert::{TryFrom, TryInto},
     env, fs,
     path::{Path, PathBuf},
@@ -205,14 +206,25 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
 ///
 /// // ^^^ first line
 /// //   | second line
+///
+/// Annotations point to the last line that actually was long enough for the
+/// range, not counting annotations themselves. So overlapping annotations are
+/// possible:
+/// ```no_run
+/// // stuff        other stuff
+/// // ^^ 'st'
+/// // ^^^^^ 'stuff'
+/// //              ^^^^^^^^^^^ 'other stuff'
+/// ```
 pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
     let mut res = Vec::new();
-    let mut prev_line_start: Option<TextSize> = Some(0.into());
+    // map from line length to beginning of last line that had that length
+    let mut line_start_map = BTreeMap::new();
     let mut line_start: TextSize = 0.into();
     let mut prev_line_annotations: Vec<(TextSize, usize)> = Vec::new();
     for line in text.split_inclusive('\n') {
         let mut this_line_annotations = Vec::new();
-        if let Some(idx) = line.find("//") {
+        let line_length = if let Some(idx) = line.find("//") {
             let annotation_offset = TextSize::of(&line[..idx + "//".len()]);
             for annotation in extract_line_annotations(&line[idx + "//".len()..]) {
                 match annotation {
@@ -222,7 +234,9 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
                         let range = if file {
                             TextRange::up_to(TextSize::of(text))
                         } else {
-                            range + prev_line_start.unwrap()
+                            let line_start = line_start_map.range(range.end()..).next().unwrap();
+
+                            range + line_start.1
                         };
                         res.push((range, content))
                     }
@@ -238,9 +252,14 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
                     }
                 }
             }
-        }
+            idx.try_into().unwrap()
+        } else {
+            TextSize::of(line)
+        };
+
+        line_start_map = line_start_map.split_off(&line_length);
+        line_start_map.insert(line_length, line_start);
 
-        prev_line_start = Some(line_start);
         line_start += TextSize::of(line);
 
         prev_line_annotations = this_line_annotations;
@@ -296,7 +315,7 @@ fn extract_line_annotations(mut line: &str) -> Vec<LineAnnotation> {
 }
 
 #[test]
-fn test_extract_annotations() {
+fn test_extract_annotations_1() {
     let text = stdx::trim_indent(
         r#"
 fn main() {
@@ -321,6 +340,25 @@ fn main() {
     assert_eq!(res[3].0.len(), 115);
 }
 
+#[test]
+fn test_extract_annotations_2() {
+    let text = stdx::trim_indent(
+        r#"
+fn main() {
+    (x,   y);
+   //^ a
+      //  ^ b
+  //^^^^^^^^ c
+}"#,
+    );
+    let res = extract_annotations(&text)
+        .into_iter()
+        .map(|(range, ann)| (&text[range], ann))
+        .collect::<Vec<_>>();
+
+    assert_eq!(res, [("x", "a".into()), ("y", "b".into()), ("(x,   y)", "c".into())]);
+}
+
 /// Returns `false` if slow tests should not run, otherwise returns `true` and
 /// also creates a file at `./target/.slow_tests_cookie` which serves as a flag
 /// that slow tests did run.