228 files changed, 8634 insertions, 7953 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index da4afb5eb..6ce377710 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -9,8 +9,8 @@ use test_utils::{
 use vfs::{file_set::FileSet, VfsPath};
 use crate::{
-    input::CrateName, Change, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, FileRange,
+    input::CrateName, Change, CrateDisplayName, CrateGraph, CrateId, Edition, Env, FileId,
-    SourceDatabaseExt, SourceRoot, SourceRootId,
+    FilePosition, FileRange, SourceDatabaseExt, SourceRoot, SourceRootId,
 };
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
@@ -24,6 +24,14 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
        (db, fixture.files[0])
    }
+    fn with_many_files(ra_fixture: &str) -> (Self, Vec<FileId>) {
+        let fixture = ChangeFixture::parse(ra_fixture);
+        let mut db = Self::default();
+        fixture.change.apply(&mut db);
+        assert!(fixture.file_position.is_none());
+        (db, fixture.files)
+    }
    fn with_files(ra_fixture: &str) -> Self {
        let fixture = ChangeFixture::parse(ra_fixture);
        let mut db = Self::default();
@@ -73,7 +81,7 @@ pub struct ChangeFixture {
 impl ChangeFixture {
    pub fn parse(ra_fixture: &str) -> ChangeFixture {
-        let fixture = Fixture::parse(ra_fixture);
+        let (mini_core, fixture) = Fixture::parse(ra_fixture);
        let mut change = Change::new();
        let mut files = Vec::new();
@@ -98,7 +106,7 @@ impl ChangeFixture {
                    let (range_or_offset, text) = extract_range_or_offset(&entry.text);
                    assert!(file_position.is_none());
                    file_position = Some((file_id, range_or_offset));
-                    text.to_string()
+                    text
                }
            } else {
                entry.text.clone()
@@ -106,6 +114,9 @@ impl ChangeFixture {
            let meta = FileMeta::from(entry);
            assert!(meta.path.starts_with(&source_root_prefix));
+            if !meta.deps.is_empty() {
+                assert!(meta.krate.is_some(), "can't specify deps without naming the crate")
+            }
            if meta.introduce_new_source_root {
                roots.push(SourceRoot::new_local(mem::take(&mut file_set)));
@@ -158,6 +169,31 @@ impl ChangeFixture {
            }
        }
+        if let Some(mini_core) = mini_core {
+            let core_file = file_id;
+            file_id.0 += 1;
+            let mut fs = FileSet::default();
+            fs.insert(core_file, VfsPath::new_virtual_path("/sysroot/core/lib.rs".to_string()));
+            roots.push(SourceRoot::new_library(fs));
+            change.change_file(core_file, Some(Arc::new(mini_core.source_code())));
+            let all_crates = crate_graph.crates_in_topological_order();
+            let core_crate = crate_graph.add_crate_root(
+                core_file,
+                Edition::Edition2021,
+                Some(CrateDisplayName::from_canonical_name("core".to_string())),
+                CfgOptions::default(),
+                Env::default(),
+                Vec::new(),
+            );
+            for krate in all_crates {
+                crate_graph.add_dep(krate, CrateName::new("core").unwrap(), core_crate).unwrap();
+            }
+        }
        roots.push(SourceRoot::new_local(mem::take(&mut file_set)));
        change.set_roots(roots);
        change.set_crate_graph(crate_graph);
@@ -166,6 +202,7 @@ impl ChangeFixture {
    }
 }
+#[derive(Debug)]
 struct FileMeta {
    path: String,
    krate: Option<String>,
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index 03b8dd767..916d39a0b 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;
@@ -52,6 +52,7 @@ impl CfgOptions {
    }
 }
+#[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 +60,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/has_source.rs b/crates/hir/src/has_source.rs
index dc10a4d0f..197149c5e 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -127,7 +127,7 @@ impl HasSource for Impl {
 }
 impl HasSource for TypeParam {
-    type Ast = Either<ast::Trait, ast::TypeParam>;
+    type Ast = Either<ast::TypeParam, ast::Trait>;
    fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
        let child_source = self.id.parent.child_source(db.upcast());
        Some(child_source.map(|it| it[self.id.local_id].clone()))
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 5bc0b2338..b7eabaabb 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -2688,18 +2688,6 @@ impl ScopeDef {
        items
    }
-    pub fn is_value_def(&self) -> bool {
-        matches!(
-            self,
-            ScopeDef::ModuleDef(ModuleDef::Function(_))
-                | ScopeDef::ModuleDef(ModuleDef::Variant(_))
-                | ScopeDef::ModuleDef(ModuleDef::Const(_))
-                | ScopeDef::ModuleDef(ModuleDef::Static(_))
-                | ScopeDef::GenericParam(GenericParam::ConstParam(_))
-                | ScopeDef::Local(_)
-        )
-    }
 }
 impl From<ItemInNs> for ScopeDef {
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 613266e07..43162797e 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -51,12 +51,14 @@ impl PathResolution {
            PathResolution::Def(ModuleDef::BuiltinType(builtin)) => {
                Some(TypeNs::BuiltinType((*builtin).into()))
            }
-            PathResolution::Def(ModuleDef::Const(_))
+            PathResolution::Def(
-            | PathResolution::Def(ModuleDef::Variant(_))
+                ModuleDef::Const(_)
-            | PathResolution::Def(ModuleDef::Function(_))
+                | ModuleDef::Variant(_)
-            | PathResolution::Def(ModuleDef::Module(_))
+                | ModuleDef::Function(_)
-            | PathResolution::Def(ModuleDef::Static(_))
+                | ModuleDef::Module(_)
-            | PathResolution::Def(ModuleDef::Trait(_)) => None,
+                | ModuleDef::Static(_)
+                | ModuleDef::Trait(_),
+            ) => None,
            PathResolution::Def(ModuleDef::TypeAlias(alias)) => {
                Some(TypeNs::TypeAliasId((*alias).into()))
            }
@@ -65,8 +67,7 @@ impl PathResolution {
            }
            PathResolution::TypeParam(param) => Some(TypeNs::GenericParam((*param).into())),
            PathResolution::SelfType(impl_def) => Some(TypeNs::SelfType((*impl_def).into())),
-            PathResolution::AssocItem(AssocItem::Const(_))
+            PathResolution::AssocItem(AssocItem::Const(_) | AssocItem::Function(_)) => None,
-            | PathResolution::AssocItem(AssocItem::Function(_)) => None,
            PathResolution::AssocItem(AssocItem::TypeAlias(alias)) => {
                Some(TypeNs::TypeAliasId((*alias).into()))
            }
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 6933f6e3c..0f04b2bae 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -92,7 +92,7 @@ pub enum WherePredicateTypeTarget {
 #[derive(Default)]
 pub(crate) struct SourceMap {
-    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
+    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::TypeParam, ast::Trait>>,
    lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
    const_params: ArenaMap<LocalConstParamId, ast::ConstParam>,
 }
@@ -199,7 +199,7 @@ impl GenericParams {
                    default: None,
                    provenance: TypeParamProvenance::TraitSelf,
                });
-                sm.type_params.insert(self_param_id, Either::Left(src.value.clone()));
+                sm.type_params.insert(self_param_id, Either::Right(src.value.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                let self_param = TypeRef::Path(name![Self].into());
@@ -277,7 +277,7 @@ impl GenericParams {
                provenance: TypeParamProvenance::TypeParamList,
            };
            let param_id = self.types.alloc(param);
-            sm.type_params.insert(param_id, Either::Right(type_param.clone()));
+            sm.type_params.insert(param_id, Either::Left(type_param.clone()));
            let type_ref = TypeRef::Path(name.into());
            self.fill_bounds(lower_ctx, &type_param, Either::Left(type_ref));
@@ -413,7 +413,7 @@ impl GenericParams {
 }
 impl HasChildSource<LocalTypeParamId> for GenericDefId {
-    type Value = Either<ast::Trait, ast::TypeParam>;
+    type Value = Either<ast::TypeParam, ast::Trait>;
    fn child_source(
        &self,
        db: &dyn DefDatabase,
@@ -449,7 +449,7 @@ impl ChildBySource for GenericDefId {
        let sm = sm.as_ref();
        for (local_id, src) in sm.value.type_params.iter() {
            let id = TypeParamId { parent: *self, local_id };
-            if let Either::Right(type_param) = src {
+            if let Either::Left(type_param) = src {
                res[keys::TYPE_PARAM].insert(sm.with_value(type_param.clone()), id)
            }
        }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 3f90bda74..5b1386406 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -674,7 +674,7 @@ impl<'a> Ctx<'a> {
                    default: None,
                    provenance: TypeParamProvenance::TraitSelf,
                });
-                sm.type_params.insert(self_param_id, Either::Left(trait_def.clone()));
+                sm.type_params.insert(self_param_id, Either::Right(trait_def.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                let self_param = TypeRef::Path(name![Self].into());
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index b1e1b70d0..e63bc8232 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -63,7 +63,7 @@ impl<'a> Printer<'a> {
    fn blank(&mut self) {
        let mut iter = self.buf.chars().rev().fuse();
        match (iter.next(), iter.next()) {
-            (Some('\n'), Some('\n')) | (Some('\n'), None) | (None, None) => {}
+            (Some('\n'), Some('\n') | None) | (None, None) => {}
            (Some('\n'), Some(_)) => {
                self.buf.push('\n');
            }
@@ -77,7 +77,7 @@ impl<'a> Printer<'a> {
    fn whitespace(&mut self) {
        match self.buf.chars().next_back() {
-            None | Some('\n') | Some(' ') => {}
+            None | Some('\n' | ' ') => {}
            _ => self.buf.push(' '),
        }
    }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 6fab58f15..927a7b6e8 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1260,7 +1260,7 @@ impl DefCollector<'_> {
        for directive in &self.unresolved_imports {
            if let ImportSource::Import { id: import, use_tree } = &directive.import.source {
                match (directive.import.path.segments().first(), &directive.import.path.kind) {
-                    (Some(krate), PathKind::Plain) | (Some(krate), PathKind::Abs) => {
+                    (Some(krate), PathKind::Plain | PathKind::Abs) => {
                        if diagnosed_extern_crates.contains(krate) {
                            continue;
                        }
@@ -1992,8 +1992,8 @@ mod tests {
        collector.def_map
    }
-    fn do_resolve(code: &str) -> DefMap {
+    fn do_resolve(not_ra_fixture: &str) -> DefMap {
-        let (db, _file_id) = TestDB::with_single_file(code);
+        let (db, _file_id) = TestDB::with_single_file(not_ra_fixture);
        let krate = db.test_crate();
        let edition = db.crate_graph()[krate].edition;
@@ -2005,24 +2005,37 @@ mod tests {
    fn test_macro_expand_will_stop_1() {
        do_resolve(
            r#"
-        macro_rules! foo {
+macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)*); }
+    ($($ty:ty)*) => { foo!($($ty)*); }
-        }
+}
-        foo!(KABOOM);
+foo!(KABOOM);
-        "#,
+"#,
+        );
+        do_resolve(
+            r#"
+macro_rules! foo {
+    ($($ty:ty)*) => { foo!(() $($ty)*); }
+}
+foo!(KABOOM);
+"#,
        );
    }
-    #[ignore] // this test does succeed, but takes quite a while :/
+    #[ignore]
    #[test]
    fn test_macro_expand_will_stop_2() {
+        // FIXME: this test does succeed, but takes quite a while: 90 seconds in
+        // the release mode. That's why the argument is not an ra_fixture --
+        // otherwise injection highlighting gets stuck.
+        //
+        // We need to find a way to fail this faster.
        do_resolve(
            r#"
-        macro_rules! foo {
+macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
+    ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
-        }
+}
-        foo!(KABOOM);
+foo!(KABOOM);
-        "#,
+"#,
        );
    }
 }
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index d4681fa3e..49c573087 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -605,8 +605,7 @@ fn to_value_ns(per_ns: PerNs) -> Option<ValueNs> {
        ModuleDefId::ConstId(it) => ValueNs::ConstId(it),
        ModuleDefId::StaticId(it) => ValueNs::StaticId(it),
-        ModuleDefId::AdtId(AdtId::EnumId(_))
+        ModuleDefId::AdtId(AdtId::EnumId(_) | AdtId::UnionId(_))
-        | ModuleDefId::AdtId(AdtId::UnionId(_))
        | ModuleDefId::TraitId(_)
        | ModuleDefId::TypeAliasId(_)
        | ModuleDefId::BuiltinType(_)
@@ -641,8 +640,7 @@ pub trait HasResolver: Copy {
 impl HasResolver for ModuleId {
    fn resolver(self, db: &dyn DefDatabase) -> Resolver {
        let mut def_map = self.def_map(db);
-        let mut modules = Vec::new();
+        let mut modules = vec![(def_map.clone(), self.local_id)];
-        modules.push((def_map.clone(), self.local_id));
        while let Some(parent) = def_map.parent() {
            def_map = parent.def_map(db);
            modules.push((def_map.clone(), parent.local_id));
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index 83500f54e..aeb1e7726 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -172,9 +172,8 @@ impl Visibility {
    /// visible in unrelated modules).
    pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
        match (self, other) {
-            (Visibility::Module(_), Visibility::Public)
+            (Visibility::Module(_) | Visibility::Public, Visibility::Public)
-            | (Visibility::Public, Visibility::Module(_))
+            | (Visibility::Public, Visibility::Module(_)) => Some(Visibility::Public),
-            | (Visibility::Public, Visibility::Public) => Some(Visibility::Public),
            (Visibility::Module(mod_a), Visibility::Module(mod_b)) => {
                if mod_a.krate != mod_b.krate {
                    return None;
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index f24d1d919..4c83a2efe 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -202,7 +202,7 @@ fn assert_expand(
    let arg_tts = args.into_iter().flat_map(|arg| {
        quote! { &(#arg), }
-    }.token_trees).collect::<Vec<_>>();
+    }.token_trees);
    let expanded = quote! {
        { { (##arg_tts); } }
@@ -254,7 +254,7 @@ fn format_args_expand(
    let _format_string = args.remove(0);
    let arg_tts = args.into_iter().flat_map(|arg| {
        quote! { std::fmt::ArgumentV1::new(&(#arg), std::fmt::Display::fmt), }
-    }.token_trees).collect::<Vec<_>>();
+    }.token_trees);
    let expanded = quote! {
        std::fmt::Arguments::new_v1(&[], &[##arg_tts])
    };
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 05c6c3fb1..848522411 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -146,10 +146,11 @@ impl HygieneInfo {
                (&self.macro_arg.1, InFile::new(loc.kind.file_id(), arg_start))
            }
            mbe::Origin::Def => match (&*self.macro_def, self.def_start) {
-                (TokenExpander::MacroDef { def_site_token_map, .. }, Some(tt))
+                (
-                | (TokenExpander::MacroRules { def_site_token_map, .. }, Some(tt)) => {
+                    TokenExpander::MacroDef { def_site_token_map, .. }
-                    (def_site_token_map, tt)
+                    | TokenExpander::MacroRules { def_site_token_map, .. },
-                }
+                    Some(tt),
+                ) => (def_site_token_map, tt),
                _ => panic!("`Origin::Def` used with non-`macro_rules!` macro"),
            },
        };
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 33107aa24..c31426d7c 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -368,10 +368,11 @@ impl ExpansionInfo {
        let (token_map, tt) = match origin {
            mbe::Origin::Call => (&self.macro_arg.1, self.arg.clone()),
            mbe::Origin::Def => match (&*self.macro_def, self.def.as_ref()) {
-                (db::TokenExpander::MacroRules { def_site_token_map, .. }, Some(tt))
+                (
-                | (db::TokenExpander::MacroDef { def_site_token_map, .. }, Some(tt)) => {
+                    db::TokenExpander::MacroRules { def_site_token_map, .. }
-                    (def_site_token_map, tt.as_ref().map(|tt| tt.syntax().clone()))
+                    | db::TokenExpander::MacroDef { def_site_token_map, .. },
-                }
+                    Some(tt),
+                ) => (def_site_token_map, tt.as_ref().map(|tt| tt.syntax().clone())),
                _ => panic!("`Origin::Def` used with non-`macro_rules!` macro"),
            },
        };
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index a1894e8d8..74129eb21 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -20,7 +20,7 @@ rustc-hash = "1.1.0"
 scoped-tls = "1"
 chalk-solve = { version = "0.68", default-features = false }
 chalk-ir = "0.68"
-chalk-recursive = "0.68"
+chalk-recursive = { version = "0.68", default-features = false }
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 once_cell = { version = "1.5.0" }
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/consteval.rs b/crates/hir_ty/src/consteval.rs
index 6f0bf8f8c..ab1afce08 100644
--- a/crates/hir_ty/src/consteval.rs
+++ b/crates/hir_ty/src/consteval.rs
@@ -38,8 +38,7 @@ impl ConstExt for Const {
 // FIXME: support more than just evaluating literals
 pub fn eval_usize(expr: &Expr) -> Option<u64> {
    match expr {
-        Expr::Literal(Literal::Uint(v, None))
+        Expr::Literal(Literal::Uint(v, None | Some(BuiltinUint::Usize))) => (*v).try_into().ok(),
-        | Expr::Literal(Literal::Uint(v, Some(BuiltinUint::Usize))) => (*v).try_into().ok(),
        _ => None,
    }
 }
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index b809b96a0..dc8f20138 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -56,7 +56,7 @@ impl BodyValidationDiagnostic {
    pub fn collect(db: &dyn HirDatabase, owner: DefWithBodyId) -> Vec<BodyValidationDiagnostic> {
        let _p = profile::span("BodyValidationDiagnostic::collect");
        let infer = db.infer(owner);
-        let mut validator = ExprValidator::new(owner, infer.clone());
+        let mut validator = ExprValidator::new(owner, infer);
        validator.validate_body(db);
        validator.diagnostics
    }
diff --git a/crates/hir_ty/src/diagnostics/match_check/deconstruct_pat.rs b/crates/hir_ty/src/diagnostics/match_check/deconstruct_pat.rs
index 471cd4921..e3d640a79 100644
--- a/crates/hir_ty/src/diagnostics/match_check/deconstruct_pat.rs
+++ b/crates/hir_ty/src/diagnostics/match_check/deconstruct_pat.rs
@@ -84,10 +84,7 @@ impl IntRange {
    #[inline]
    fn is_integral(ty: &Ty) -> bool {
        match ty.kind(&Interner) {
-            TyKind::Scalar(Scalar::Char)
+            TyKind::Scalar(Scalar::Char | Scalar::Int(_) | Scalar::Uint(_) | Scalar::Bool) => true,
-            | TyKind::Scalar(Scalar::Int(_))
-            | TyKind::Scalar(Scalar::Uint(_))
-            | TyKind::Scalar(Scalar::Bool) => true,
            _ => false,
        }
    }
@@ -381,7 +378,7 @@ impl Constructor {
            // Wildcards cover anything
            (_, Wildcard) => true,
            // The missing ctors are not covered by anything in the matrix except wildcards.
-            (Missing, _) | (Wildcard, _) => false,
+            (Missing | Wildcard, _) => false,
            (Single, Single) => true,
            (Variant(self_id), Variant(other_id)) => self_id == other_id,
@@ -523,7 +520,7 @@ impl SplitWildcard {
                }
            }
            TyKind::Scalar(Scalar::Char) => unhandled(),
-            TyKind::Scalar(Scalar::Int(..)) | TyKind::Scalar(Scalar::Uint(..)) => unhandled(),
+            TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(),
            TyKind::Never if !cx.feature_exhaustive_patterns() && !pcx.is_top_level => {
                smallvec![NonExhaustive]
            }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 4b7f31521..7be914451 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -47,10 +47,7 @@ impl<'a> InferenceContext<'a> {
        // pointers to have a chance at getting a match. See
        // https://github.com/rust-lang/rust/blob/7b805396bf46dce972692a6846ce2ad8481c5f85/src/librustc_typeck/check/coercion.rs#L877-L916
        let sig = match (ty1.kind(&Interner), ty2.kind(&Interner)) {
-            (TyKind::FnDef(..), TyKind::FnDef(..))
+            (TyKind::FnDef(..) | TyKind::Closure(..), TyKind::FnDef(..) | TyKind::Closure(..)) => {
-            | (TyKind::Closure(..), TyKind::FnDef(..))
-            | (TyKind::FnDef(..), TyKind::Closure(..))
-            | (TyKind::Closure(..), TyKind::Closure(..)) => {
                // FIXME: we're ignoring safety here. To be more correct, if we have one FnDef and one Closure,
                // we should be coercing the closure to a fn pointer of the safety of the FnDef
                cov_mark::hit!(coerce_fn_reification);
@@ -448,8 +445,7 @@ fn safe_to_unsafe_fn_ty(fn_ty: FnPointer) -> FnPointer {
 fn coerce_mutabilities(from: Mutability, to: Mutability) -> Result<(), TypeError> {
    match (from, to) {
-        (Mutability::Mut, Mutability::Mut)
+        (Mutability::Mut, Mutability::Mut | Mutability::Not)
-        | (Mutability::Mut, Mutability::Not)
        | (Mutability::Not, Mutability::Not) => Ok(()),
        (Mutability::Not, Mutability::Mut) => Err(TypeError),
    }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 5ea2e5934..c3a5b979f 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -367,7 +367,7 @@ impl<'a> InferenceContext<'a> {
            Expr::Path(p) => {
                // FIXME this could be more efficient...
                let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
-                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(self.err_ty())
+                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or_else(|| self.err_ty())
            }
            Expr::Continue { .. } => TyKind::Never.intern(&Interner),
            Expr::Break { expr, label } => {
@@ -511,7 +511,7 @@ impl<'a> InferenceContext<'a> {
                        _ => None,
                    }
                })
-                .unwrap_or(self.err_ty());
+                .unwrap_or_else(|| self.err_ty());
                let ty = self.insert_type_vars(ty);
                self.normalize_associated_types_in(ty)
            }
@@ -593,11 +593,11 @@ impl<'a> InferenceContext<'a> {
                    UnaryOp::Neg => {
                        match inner_ty.kind(&Interner) {
                            // Fast path for builtins
-                            TyKind::Scalar(Scalar::Int(_))
+                            TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_))
-                            | TyKind::Scalar(Scalar::Uint(_))
+                            | TyKind::InferenceVar(
-                            | TyKind::Scalar(Scalar::Float(_))
+                                _,
-                            | TyKind::InferenceVar(_, TyVariableKind::Integer)
+                                TyVariableKind::Integer | TyVariableKind::Float,
-                            | TyKind::InferenceVar(_, TyVariableKind::Float) => inner_ty,
+                            ) => inner_ty,
                            // Otherwise we resolve via the std::ops::Neg trait
                            _ => self
                                .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
@@ -606,9 +606,7 @@ impl<'a> InferenceContext<'a> {
                    UnaryOp::Not => {
                        match inner_ty.kind(&Interner) {
                            // Fast path for builtins
-                            TyKind::Scalar(Scalar::Bool)
+                            TyKind::Scalar(Scalar::Bool | Scalar::Int(_) | Scalar::Uint(_))
-                            | TyKind::Scalar(Scalar::Int(_))
-                            | TyKind::Scalar(Scalar::Uint(_))
                            | TyKind::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
                            // Otherwise we resolve via the std::ops::Not trait
                            _ => self
@@ -735,7 +733,7 @@ impl<'a> InferenceContext<'a> {
            Expr::Array(array) => {
                let elem_ty =
                    match expected.to_option(&mut self.table).as_ref().map(|t| t.kind(&Interner)) {
-                        Some(TyKind::Array(st, _)) | Some(TyKind::Slice(st)) => st.clone(),
+                        Some(TyKind::Array(st, _) | TyKind::Slice(st)) => st.clone(),
                        _ => self.table.new_type_var(),
                    };
@@ -820,8 +818,10 @@ impl<'a> InferenceContext<'a> {
        for stmt in statements {
            match stmt {
                Statement::Let { pat, type_ref, initializer } => {
-                    let decl_ty =
+                    let decl_ty = type_ref
-                        type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(self.err_ty());
+                        .as_ref()
+                        .map(|tr| self.make_ty(tr))
+                        .unwrap_or_else(|| self.err_ty());
                    // Always use the declared type when specified
                    let mut ty = decl_ty.clone();
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 035f4ded6..c79ed91ea 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -192,7 +192,7 @@ impl<'a> InferenceContext<'a> {
            Pat::Path(path) => {
                // FIXME use correct resolver for the surrounding expression
                let resolver = self.resolver.clone();
-                self.infer_path(&resolver, path, pat.into()).unwrap_or(self.err_ty())
+                self.infer_path(&resolver, path, pat.into()).unwrap_or_else(|| self.err_ty())
            }
            Pat::Bind { mode, name: _, subpat } => {
                let mode = if mode == &BindingAnnotation::Unannotated {
@@ -297,10 +297,11 @@ fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
            Expr::Literal(Literal::String(..)) => false,
            _ => true,
        },
-        Pat::Bind { mode: BindingAnnotation::Mutable, subpat: Some(subpat), .. }
+        Pat::Bind {
-        | Pat::Bind { mode: BindingAnnotation::Unannotated, subpat: Some(subpat), .. } => {
+            mode: BindingAnnotation::Mutable | BindingAnnotation::Unannotated,
-            is_non_ref_pat(body, *subpat)
+            subpat: Some(subpat),
-        }
+            ..
+        } => is_non_ref_pat(body, *subpat),
        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => false,
    }
 }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 817a65c20..ea03b6a6c 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -562,7 +562,7 @@ impl<'a> TyLoweringContext<'a> {
                },
            );
-            ty.unwrap_or(TyKind::Error.intern(&Interner))
+            ty.unwrap_or_else(|| TyKind::Error.intern(&Interner))
        } else {
            TyKind::Error.intern(&Interner)
        }
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs
index 0222de2bc..5ef6342d5 100644
--- a/crates/hir_ty/src/op.rs
+++ b/crates/hir_ty/src/op.rs
@@ -8,17 +8,15 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
    match op {
        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
        BinaryOp::Assignment { .. } => TyBuilder::unit(),
-        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
+        BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) => {
            // all integer combinations are valid here
            if matches!(
                lhs_ty.kind(&Interner),
-                TyKind::Scalar(Scalar::Int(_))
+                TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_))
-                    | TyKind::Scalar(Scalar::Uint(_))
                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
            ) && matches!(
                rhs_ty.kind(&Interner),
-                TyKind::Scalar(Scalar::Int(_))
+                TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_))
-                    | TyKind::Scalar(Scalar::Uint(_))
                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
            ) {
                lhs_ty
@@ -32,15 +30,15 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::Scalar(Scalar::Uint(_)))
            | (TyKind::Scalar(Scalar::Float(_)), TyKind::Scalar(Scalar::Float(_))) => rhs_ty,
            // ({int}, int) | ({int}, uint)
-            (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Int(_)))
+            (
-            | (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Uint(_))) => {
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
-                rhs_ty
+                TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)),
-            }
+            ) => rhs_ty,
            // (int, {int}) | (uint, {int})
-            (TyKind::Scalar(Scalar::Int(_)), TyKind::InferenceVar(_, TyVariableKind::Integer))
+            (
-            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::InferenceVar(_, TyVariableKind::Integer)) => {
+                TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)),
-                lhs_ty
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
-            }
+            ) => lhs_ty,
            // ({float} | float)
            (TyKind::InferenceVar(_, TyVariableKind::Float), TyKind::Scalar(Scalar::Float(_))) => {
                rhs_ty
@@ -69,21 +67,15 @@ pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
        BinaryOp::Assignment { op: None } => lhs_ty,
        BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty.kind(&Interner) {
            TyKind::Scalar(_) | TyKind::Str => lhs_ty,
-            TyKind::InferenceVar(_, TyVariableKind::Integer)
+            TyKind::InferenceVar(_, TyVariableKind::Integer | TyVariableKind::Float) => lhs_ty,
-            | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
            _ => TyKind::Error.intern(&Interner),
        },
-        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
+        BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) => TyKind::Error.intern(&Interner),
-            TyKind::Error.intern(&Interner)
-        }
        BinaryOp::CmpOp(CmpOp::Ord { .. })
        | BinaryOp::Assignment { op: Some(_) }
        | BinaryOp::ArithOp(_) => match lhs_ty.kind(&Interner) {
-            TyKind::Scalar(Scalar::Int(_))
+            TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_)) => lhs_ty,
-            | TyKind::Scalar(Scalar::Uint(_))
+            TyKind::InferenceVar(_, TyVariableKind::Integer | TyVariableKind::Float) => lhs_ty,
-            | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
-            TyKind::InferenceVar(_, TyVariableKind::Integer)
-            | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
            _ => TyKind::Error.intern(&Interner),
        },
    }
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)
+    check_impl(ra_fixture, false, true, 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");
 }
 fn check_no_mismatches(ra_fixture: &str) {
-    check_mismatches_impl(ra_fixture, true)
+    check_impl(ra_fixture, true, false, false)
 }
-#[allow(unused)]
+fn check(ra_fixture: &str) {
-fn check_mismatches(ra_fixture: &str) {
+    check_impl(ra_fixture, false, false, false)
-    check_mismatches_impl(ra_fixture, 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 (db, files) = TestDB::with_many_files(ra_fixture);
-    let module = db.module_for_file(file_id);
-    let def_map = module.def_map(&db);
+    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 unexpected_type_mismatches = String::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);
-    };
    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) {
+            let node = match pat_node(&body_source_map, pat, &db) {
-                Ok(sp) => {
+                Some(value) => value,
-                    let root = db.parse_or_expand(sp.file_id).unwrap();
+                None => continue,
-                    sp.map(|ptr| {
-                        ptr.either(
-                            |it| it.to_node(&root).syntax().clone(),
-                            |it| it.to_node(&root).syntax().clone(),
-                        )
-                    })
-                }
-                Err(SyntheticSyntax) => 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 range = node.as_ref().original_file_range(&db);
-        }
+            let actual = format!(
-    }
+                "expected {}, got {}",
-    let mut checked_one = false;
+                mismatch.expected.display_test(&db),
-    for (file_id, annotations) in db.extract_annotations() {
+                mismatch.actual.display_test(&db)
-        for (range, expected) in annotations {
+            );
-            let file_range = FileRange { file_id, range };
+            if let Some(annotation) = mismatches.remove(&range) {
-            if let Some(mismatch) = mismatches.remove(&file_range) {
+                assert_eq!(actual, annotation);
-                assert_eq!(mismatch, expected);
            } 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 {
+    if !unexpected_type_mismatches.is_empty() {
-        format_to!(buf, "{:?}: {}\n", range.range, mismatch,);
+        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 {
+fn pat_node(
-    let file = db.parse(pos.file_id).ok().unwrap();
+    body_source_map: &BodySourceMap,
-    let expr = algo::find_node_at_range::<ast::Expr>(file.syntax(), pos.range).unwrap();
+    pat: PatId,
-    let fn_def = expr.syntax().ancestors().find_map(ast::Fn::cast).unwrap();
+    db: &TestDB,
-    let module = db.module_for_file(pos.file_id);
+) -> Option<InFile<SyntaxNode>> {
-    let func = *module.child_by_source(db)[keys::FUNCTION]
+    Some(match body_source_map.pat_syntax(pat) {
-        .get(&InFile::new(pos.file_id.into(), fn_def))
+        Ok(sp) => {
-        .unwrap();
+            let root = db.parse_or_expand(sp.file_id).unwrap();
+            sp.map(|ptr| {
-    let (_body, source_map) = db.body_with_source_map(func.into());
+                ptr.either(
-    if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
+                    |it| it.to_node(&root).syntax().clone(),
-        let infer = db.infer(func.into());
+                    |it| it.to_node(&root).syntax().clone(),
-        return infer[expr_id].clone();
+                )
-    }
+            })
-    panic!("Can't find expression")
+        }
+        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 71047703d..87089f09d 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -1,380 +1,157 @@
-use expect_test::expect;
+use super::{check, check_no_mismatches, check_types};
-use super::{check_infer, check_infer_with_mismatches, check_no_mismatches, check_types};
 #[test]
-fn infer_block_expr_type_mismatch() {
+fn block_expr_type_mismatch() {
-    check_infer(
+    // FIXME fix double type mismatch
+    check(
        r"
-        fn test() {
+fn test() {
-            let a: i32 = { 1i64 };
+    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#"
-        struct S<T> { a: T }
+//- minicore: coerce_unsized
+struct S<T> { a: T }
-        fn f<T>(_: &[T]) -> T { loop {} }
+fn f<T>(_: &[T]) -> T { loop {} }
-        fn g<T>(_: S<&[T]>) -> T { loop {} }
+fn g<T>(_: S<&[T]>) -> T { loop {} }
-        fn gen<T>() -> *mut [T; 2] { loop {} }
+fn gen<T>() -> *mut [T; 2] { loop {} }
-        fn test1<U>() -> *mut [U] {
+fn test1<U>() -> *mut [U] {
-            gen()
+    gen()
-        }
+}
-        fn test2() {
-            let arr: &[u8; 1] = &[1];
-            let a: &[_] = arr;
-            let b = f(arr);
-            let c: &[_] = { arr };
-            let d = g(S { a: arr });
-            let e: [&[_]; 1] = [arr];
-            let f: [&[_]; 2] = [arr; 2];
-            let g: (&[_], &[_]) = (arr, arr);
-        }
-        #[lang = "sized"]
+fn test2() {
-        pub trait Sized {}
+    let arr: &[u8; 1] = &[1];
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+    let a: &[_] = arr;
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
+    let b = f(arr);
-        "#,
+    let c: &[_] = { arr };
-        expect![[r#"
+    let d = g(S { a: arr });
-            30..31 '_': &[T]
+    let e: [&[_]; 1] = [arr];
-            44..55 '{ loop {} }': T
+    let f: [&[_]; 2] = [arr; 2];
-            46..53 'loop {}': !
+    let g: (&[_], &[_]) = (arr, arr);
-            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() {
+fn let_stmt_coerce() {
-    check_infer(
+    check_no_mismatches(
        r"
-        fn test() {
+//- minicore: coerce_unsized
-            let x: &[isize] = &[1];
+fn test() {
-            let x: *const [isize] = &[1];
+    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
-        "#]],
    );
 }
 #[test]
-fn infer_custom_coerce_unsized() {
+fn custom_coerce_unsized() {
-    check_infer(
+    check(
        r#"
-        struct A<T: ?Sized>(*const T);
+//- minicore: coerce_unsized
-        struct B<T: ?Sized>(*const T);
+use core::{marker::Unsize, ops::CoerceUnsized};
-        struct C<T: ?Sized> { inner: *const T }
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
+struct A<T: ?Sized>(*const T);
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
+struct B<T: ?Sized>(*const T);
+struct C<T: ?Sized> { inner: *const T }
-        fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
-        fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
-        fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
-        fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
+fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
-            let d = foo1(a);
+fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
-            let e = foo2(b);
+fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
-            let f = foo3(c);
-        }
+fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
-        #[lang = "sized"]
+    let d = foo1(a);
-        pub trait Sized {}
+              // ^ expected A<[{unknown}]>, got A<[u8; 2]>
-        #[lang = "unsize"]
+    let e = foo2(b);
-        pub trait Unsize<T: ?Sized> {}
+     // ^ type: B<[u8]>
-        #[lang = "coerce_unsized"]
+    let f = foo3(c);
-        pub trait CoerceUnsized<T> {}
+     // ^ type: C<[u8]>
+}
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+"#,
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
-        expect![[r#"
-            257..258 'x': A<[T]>
-            278..283 '{ x }': A<[T]>
-            280..281 'x': A<[T]>
-            295..296 'x': B<[T]>
-            316..321 '{ x }': B<[T]>
-            318..319 'x': B<[T]>
-            333..334 'x': C<[T]>
-            354..359 '{ x }': C<[T]>
-            356..357 'x': C<[T]>
-            369..370 'a': A<[u8; 2]>
-            384..385 'b': B<[u8; 2]>
-            399..400 'c': C<[u8; 2]>
-            414..480 '{     ...(c); }': ()
-            424..425 'd': A<[{unknown}]>
-            428..432 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
-            428..435 'foo1(a)': A<[{unknown}]>
-            433..434 'a': A<[u8; 2]>
-            445..446 'e': B<[u8]>
-            449..453 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
-            449..456 'foo2(b)': B<[u8]>
-            454..455 'b': B<[u8; 2]>
-            466..467 'f': C<[u8]>
-            470..474 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
-            470..477 'foo3(c)': C<[u8]>
-            475..476 'c': C<[u8; 2]>
-        "#]],
    );
 }
 #[test]
-fn infer_if_coerce() {
+fn if_coerce() {
-    check_infer(
+    check_no_mismatches(
        r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
-        fn test() {
+fn foo<T>(x: &[T]) -> &[T] { x }
-            let x = if true {
+fn test() {
-                foo(&[1])
+    let x = if true {
-            } else {
+        foo(&[1])
-                &[1]
+    } else {
-            };
+        &[1]
-        }
+    };
+}
+"#,
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        "#,
-        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() {
+fn if_else_coerce() {
-    check_infer(
+    check_no_mismatches(
        r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
-        fn test() {
+fn foo<T>(x: &[T]) -> &[T] { x }
-            let x = if true {
+fn test() {
-                &[1]
+    let x = if true {
-            } else {
+        &[1]
-                foo(&[1])
+    } else {
-            };
+        foo(&[1])
-        }
+    };
+}
-        #[lang = "sized"]
+"#,
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
-        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() {
+fn match_first_coerce() {
-    check_infer(
+    check_no_mismatches(
        r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
-        fn test(i: i32) {
+fn foo<T>(x: &[T]) -> &[T] { x }
-            let x = match i {
+fn test(i: i32) {
-                2 => foo(&[2]),
+    let x = match i {
-                1 => &[1],
+        2 => foo(&[2]),
-                _ => &[3],
+        1 => &[1],
-            };
+        _ => &[3],
-        }
+    };
+}
-        #[lang = "sized"]
+"#,
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        "#,
-        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() {
+fn match_second_coerce() {
-    check_infer(
+    check_no_mismatches(
        r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
+//- minicore: coerce_unsized
-        fn test(i: i32) {
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
-            let x = match i {
+fn test(i: i32) {
-                1 => &[1],
+    let x = match i {
-                2 => foo(&[2]),
+        1 => &[1],
-                _ => &[3],
+        2 => foo(&[2]),
-            };
+        _ => &[3],
-        }
+    };
+}
-        #[lang = "sized"]
+"#,
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
-        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
-        "#]],
    );
 }
@@ -382,207 +159,103 @@ fn infer_match_second_coerce() {
 fn coerce_merge_one_by_one1() {
    cov_mark::check!(coerce_merge_fail_fallback);
-    check_infer(
+    check(
        r"
-        fn test() {
+fn test() {
-            let t = &mut 1;
+    let t = &mut 1;
-            let x = match 1 {
+    let x = match 1 {
-                1 => t as *mut i32,
+        1 => t as *mut i32,
-                2 => t as &i32,
+        2 => t as &i32,
-                _ => t as *const 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 {
+fn foo() -> u32 {
-            return unknown;
+    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;
+struct Foo;
-        fn takes_ref_foo(x: &Foo) {}
+fn takes_ref_foo(x: &Foo) {}
-        fn test() {
+fn test() {
-            takes_ref_foo(&Foo);
+    takes_ref_foo(&Foo);
-            takes_ref_foo(&&Foo);
+    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
-        "]],
    );
 }
 #[test]
 fn coerce_autoderef_generic() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
-        r"
+        r#"
-        struct Foo;
+struct Foo;
-        fn takes_ref<T>(x: &T) -> T { *x }
+fn takes_ref<T>(x: &T) -> T { *x }
-        fn test() {
+fn test() {
-            takes_ref(&Foo);
+    takes_ref(&Foo);
-            takes_ref(&&Foo);
+    takes_ref(&&Foo);
-            takes_ref(&&&Foo);
+    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#"
-        struct String {}
+//- minicore: deref
-        #[lang = "deref"]
+struct String {}
-        trait Deref { type Target; }
+impl core::ops::Deref for String { type Target = str; }
-        impl Deref for String { type Target = str; }
+fn takes_ref_str(x: &str) {}
-        fn takes_ref_str(x: &str) {}
+fn returns_string() -> String { loop {} }
-        fn returns_string() -> String { loop {} }
+fn test() {
-        fn test() {
+    takes_ref_str(&{ returns_string() });
-            takes_ref_str(&{ returns_string() });
+}
-        }
+"#,
-        "#,
-        expect![[r"
-            126..127 'x': &str
-            135..137 '{}': ()
-            168..179 '{ loop {} }': String
-            170..177 'loop {}': !
-            175..177 '{}': ()
-            190..235 '{     ... }); }': ()
-            196..209 'takes_ref_str': fn takes_ref_str(&str)
-            196..232 'takes_...g() })': ()
-            210..231 '&{ ret...ng() }': &String
-            211..231 '{ retu...ng() }': String
-            213..227 'returns_string': fn returns_string() -> String
-            213..229 'return...ring()': String
-        "]],
    );
 }
 #[test]
 fn closure_return_coerce() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
        r"
-        fn foo() {
+fn foo() {
-            let x = || {
+    let x = || {
-                if true {
+        if true {
-                    return &1u32;
+            return &1u32;
-                }
-                &&1u32
-            };
        }
-        ",
+        &&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
-        "]],
    );
 }
 #[test]
 fn coerce_fn_item_to_fn_ptr() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
        r"
-        fn foo(x: u32) -> isize { 1 }
+fn foo(x: u32) -> isize { 1 }
-        fn test() {
+fn test() {
-            let f: fn(u32) -> isize = foo;
+    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
-        "]],
    );
 }
@@ -590,340 +263,160 @@ 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 foo1(x: u32) -> isize { 1 }
-        fn foo2(x: u32) -> isize { 2 }
+fn foo2(x: u32) -> isize { 2 }
-        fn foo3(x: u32) -> isize { 3 }
+fn foo3(x: u32) -> isize { 3 }
-        fn test() {
+fn test() {
-            let x = match 1 {
+    let x = match 1 {
-                1 => foo1,
+        1 => foo1,
-                2 => foo2,
+        2 => foo2,
-                _ => foo3,
+        _ => foo3,
-            };
+    };
-        }
+    x;
-        ",
+  //^ fn(u32) -> isize
-        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
-        "]],
    );
 }
 #[test]
 fn coerce_closure_to_fn_ptr() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
        r"
-        fn test() {
+fn test() {
-            let f: fn(u32) -> isize = |x| { 1 };
+    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
-        "]],
    );
 }
 #[test]
 fn coerce_placeholder_ref() {
    // placeholders should unify, even behind references
-    check_infer_with_mismatches(
+    check_no_mismatches(
        r"
-        struct S<T> { t: T }
+struct S<T> { t: T }
-        impl<TT> S<TT> {
+impl<TT> S<TT> {
-            fn get(&self) -> &TT {
+    fn get(&self) -> &TT {
-                &self.t
+        &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
-        "]],
    );
 }
 #[test]
 fn coerce_unsize_array() {
-    check_infer_with_mismatches(
+    check_types(
        r#"
-        #[lang = "unsize"]
+//- minicore: coerce_unsized
-        pub trait Unsize<T> {}
+fn test() {
-        #[lang = "coerce_unsized"]
+    let f: &[usize] = &[1, 2, 3];
-        pub trait CoerceUnsized<T> {}
+                      //^ usize
+}"#,
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-        fn test() {
-            let f: &[usize] = &[1, 2, 3];
-        }
-        "#,
-        expect![[r#"
-            161..198 '{     ... 3]; }': ()
-            171..172 'f': &[usize]
-            185..195 '&[1, 2, 3]': &[usize; 3]
-            186..195 '[1, 2, 3]': [usize; 3]
-            187..188 '1': usize
-            190..191 '2': usize
-            193..194 '3': usize
-        "#]],
    );
 }
 #[test]
 fn coerce_unsize_trait_object_simple() {
-    check_infer_with_mismatches(
+    check_types(
-        r#"
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-        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<_, i8, i16> = &S;
-            let obj: &dyn Foo<i8, _> = &S;
-        }
-        "#,
-        expect![[r"
-            424..539 '{     ... &S; }': ()
-            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>
-            499..501 '&S': &S<i8, i16>
-            500..501 'S': S<i8, i16>
-            511..514 'obj': &dyn Foo<i8, usize>
-            534..536 '&S': &S<i8, {unknown}>
-            535..536 'S': S<i8, {unknown}>
-        "]],
-    );
-}
-#[test]
-// The rust reference says this should be possible, but rustc doesn't implement
-// it. We used to support it, but Chalk doesn't.
-#[ignore]
-fn coerce_unsize_trait_object_to_trait_object() {
-    check_infer_with_mismatches(
        r#"
-        #[lang = "sized"]
+//- minicore: coerce_unsized
-        pub trait Sized {}
+trait Foo<T, U> {}
-        #[lang = "unsize"]
+trait Bar<U, T, X>: Foo<T, U> {}
-        pub trait Unsize<T> {}
+trait Baz<T, X>: Bar<usize, T, X> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
+struct S<T, X>;
+impl<T, X> Foo<T, usize> for S<T, X> {}
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
+impl<T, X> Bar<usize, T, X> for S<T, X> {}
+impl<T, X> Baz<T, X> for S<T, X> {}
-        trait Foo<T, U> {}
-        trait Bar<U, T, X>: Foo<T, U> {}
+fn test() {
-        trait Baz<T, X>: Bar<usize, T, X> {}
+    let obj: &dyn Baz<i8, i16> = &S;
+                                //^ S<i8, i16>
-        struct S<T, X>;
+    let obj: &dyn Bar<_, i8, i16> = &S;
-        impl<T, X> Foo<T, usize> for S<T, X> {}
+                                   //^ S<i8, i16>
-        impl<T, X> Bar<usize, T, X> for S<T, X> {}
+    let obj: &dyn Foo<i8, _> = &S;
-        impl<T, X> Baz<T, X> for S<T, X> {}
+                              //^ S<i8, {unknown}>
+}"#,
-        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"
-            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>
-        "]],
    );
 }
 #[test]
 fn coerce_unsize_super_trait_cycle() {
-    check_infer_with_mismatches(
+    check_no_mismatches(
        r#"
-        #[lang = "sized"]
+//- minicore: coerce_unsized
-        pub trait Sized {}
+trait A {}
-        #[lang = "unsize"]
+trait B: C + A {}
-        pub trait Unsize<T> {}
+trait C: B {}
-        #[lang = "coerce_unsized"]
+trait D: C
-        pub trait CoerceUnsized<T> {}
+struct S;
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
+impl A for S {}
+impl B for S {}
-        trait A {}
+impl C for S {}
-        trait B: C + A {}
+impl D for S {}
-        trait C: B {}
-        trait D: C
+fn test() {
+    let obj: &dyn D = &S;
-        struct S;
+    let obj: &dyn A = &S;
-        impl A for S {}
+}
-        impl B for S {}
+"#,
-        impl C for S {}
-        impl D for S {}
-        fn test() {
-            let obj: &dyn D = &S;
-            let obj: &dyn A = &S;
-        }
-        "#,
-        expect![[r"
-            328..383 '{     ... &S; }': ()
-            338..341 'obj': &dyn D
-            352..354 '&S': &S
-            353..354 'S': S
-            364..367 'obj': &dyn A
-            378..380 '&S': &S
-            379..380 'S': S
-        "]],
    );
 }
 #[test]
 fn coerce_unsize_generic() {
    // FIXME: fix the type mismatches here
-    check_infer_with_mismatches(
+    check(
        r#"
-        #[lang = "unsize"]
+//- minicore: coerce_unsized
-        pub trait Unsize<T> {}
+struct Foo<T> { t: T };
-        #[lang = "coerce_unsized"]
+struct Bar<T>(Foo<T>);
-        pub trait CoerceUnsized<T> {}
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-        struct Foo<T> { t: T };
-        struct Bar<T>(Foo<T>);
-        fn test() {
+fn test() {
-            let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
+    let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
-            let _: &Bar<[usize]> = &Bar(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#"
+}
-            209..317 '{     ... }); }': ()
+"#,
-            219..220 '_': &Foo<[usize]>
-            238..259 '&Foo {..., 3] }': &Foo<[usize]>
-            239..259 'Foo { ..., 3] }': Foo<[usize]>
-            248..257 '[1, 2, 3]': [usize; 3]
-            249..250 '1': usize
-            252..253 '2': usize
-            255..256 '3': usize
-            269..270 '_': &Bar<[usize]>
-            288..314 '&Bar(F... 3] })': &Bar<[i32; 3]>
-            289..292 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
-            289..314 'Bar(Fo... 3] })': Bar<[i32; 3]>
-            293..313 'Foo { ..., 3] }': Foo<[i32; 3]>
-            302..311 '[1, 2, 3]': [i32; 3]
-            303..304 '1': i32
-            306..307 '2': i32
-            309..310 '3': i32
-            248..257: expected [usize], got [usize; 3]
-            288..314: expected &Bar<[usize]>, got &Bar<[i32; 3]>
-        "#]],
    );
 }
 #[test]
 fn coerce_unsize_apit() {
    // FIXME: #8984
-    check_infer_with_mismatches(
+    check(
        r#"
-#[lang = "sized"]
+//- minicore: coerce_unsized
-pub trait Sized {}
-#[lang = "unsize"]
-pub trait Unsize<T> {}
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T> {}
-impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
 trait Foo {}
 fn test(f: impl Foo) {
    let _: &dyn Foo = &f;
+                    //^^ expected &dyn Foo, got &impl Foo
 }
        "#,
-        expect![[r#"
-            210..211 'f': impl Foo
-            223..252 '{     ... &f; }': ()
-            233..234 '_': &dyn Foo
-            247..249 '&f': &impl Foo
-            248..249 'f': impl Foo
-            247..249: 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 }
@@ -942,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#"
@@ -998,15 +491,7 @@ fn main() {
 fn coerce_unsize_expected_type() {
    check_no_mismatches(
        r#"
-#[lang = "sized"]
+//- minicore: coerce_unsized
-pub trait Sized {}
-#[lang = "unsize"]
-pub trait Unsize<T> {}
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T> {}
-impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
 fn main() {
    let foo: &[u32] = &[1, 2];
    let foo: &[u32] = match true {
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 f26b2c8a7..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 {
+trait Trait1 {
-            fn method(&self) -> u32;
+    fn method(&self) -> u32;
-        }
+}
-        struct S1;
+struct S1;
-        impl Trait1 for S1 {}
+impl Trait1 for S1 {}
-        trait Trait2 {
+trait Trait2 {
-            fn method(&self) -> i128;
+    fn method(&self) -> i128;
-        }
+}
-        struct S2;
+struct S2;
-        impl Trait2 for S2 {}
+impl Trait2 for S2 {}
-        fn test() {
+fn test() {
-            S1.method(); // -> u32
+    S1.method();
-            S2.method(); // -> i128
+  //^^^^^^^^^^^ 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;
+struct S;
-        mod foo {
+mod foo {
-            pub trait Trait1 {
+    pub trait Trait1 {
-                fn method(&self) -> u32;
+        fn method(&self) -> u32;
-            }
+    }
-            impl Trait1 for super::S {}
+    impl Trait1 for super::S {}
-        }
+}
-        mod bar {
+mod bar {
-            pub trait Trait2 {
+    pub trait Trait2 {
-                fn method(&self) -> i128;
+        fn method(&self) -> i128;
-            }
+    }
-            impl Trait2 for super::S {}
+    impl Trait2 for super::S {}
-        }
+}
-        mod foo_test {
+mod foo_test {
-            use super::S;
+    use super::S;
-            use super::foo::Trait1;
+    use super::foo::Trait1;
-            fn test() {
+    fn test() {
-                S.method(); // -> u32
+        S.method();
-            }
+      //^^^^^^^^^^ u32
-        }
+    }
+}
-        mod bar_test {
+mod bar_test {
-            use super::S;
+    use super::S;
-            use super::bar::Trait2;
+    use super::bar::Trait2;
-            fn test() {
+    fn test() {
-                S.method(); // -> i128
+        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> {
+trait Trait<T> {
-            fn method(&self) -> T;
+    fn method(&self) -> T;
-        }
+}
-        struct S;
+struct S;
-        impl Trait<u32> for S {}
+impl Trait<u32> for S {}
-        fn test() {
+fn test() {
-            S.method();
+    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> {
+trait Trait<T1, T2, T3> {
-            fn method1(&self) -> (T1, T2, T3);
+    fn method1(&self) -> (T1, T2, T3);
-            fn method2(&self) -> (T3, T2, T1);
+    fn method2(&self) -> (T3, T2, T1);
-        }
+}
-        struct S1;
+struct S1;
-        impl Trait<u8, u16, u32> for S1 {}
+impl Trait<u8, u16, u32> for S1 {}
-        struct S2;
+struct S2;
-        impl<T> Trait<i8, i16, T> for S2 {}
+impl<T> Trait<i8, i16, T> for S2 {}
-        fn test() {
+fn test() {
-            S1.method1(); // u8, u16, u32
+    S1.method1();
-            S1.method2(); // u32, u16, u8
+  //^^^^^^^^^^^^ (u8, u16, u32)
-            S2.method1(); // i8, i16, {unknown}
+    S1.method2();
-            S2.method2(); // {unknown}, i16, i8
+  //^^^^^^^^^^^^ (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> {
+trait Trait<T> {
-            fn method(&self) -> T;
+    fn method(&self) -> T;
-        }
+}
-        struct S<T>(T);
+struct S<T>(T);
-        impl<U> Trait<U> for S<U> {}
+impl<U> Trait<U> for S<U> {}
-        fn test() {
+fn test() {
-            S(1u32).method();
+    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<u32> { fn foo(&self) -> u8 { 0 } }
-impl S<i32> { fn foo(&self) -> i8 {} }
+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
 "#,
    );
 }
@@ -780,14 +744,11 @@ fn test() { (&S).foo(); }
 fn method_resolution_unsize_array() {
    check_types(
        r#"
-#[lang = "slice"]
+//- minicore: slice
-impl<T> [T] {
-    fn len(&self) -> usize { loop {} }
-}
 fn test() {
    let a = [1, 2, 3];
    a.len();
-}       //^ usize
+} //^^^^^^^ usize
 "#,
    );
 }
@@ -802,7 +763,7 @@ impl Clone for S {}
 fn test() {
    S.clone();
-          //^ S
+  //^^^^^^^^^ S
 }
 //- /lib.rs crate:core
@@ -826,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
 "#,
    );
 }
@@ -844,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}
 "#,
    );
 }
@@ -859,7 +820,7 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T: Clone> Trait for T {}
 fn test() { (&S).foo(); }
-                   //^ {unknown}
+          //^^^^^^^^^^ {unknown}
 "#,
    );
 }
@@ -874,7 +835,7 @@ struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
 fn test() { S.foo(); }
-                //^ u128
+          //^^^^^^^ u128
 "#,
    );
 }
@@ -890,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}
 "#,
    );
 }
@@ -906,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}
 "#,
    );
 }
@@ -936,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>>)
 }
 "#,
    );
@@ -950,7 +911,7 @@ fn method_resolution_encountering_fn_type() {
 fn foo() {}
 trait FnOnce { fn call(self); }
 fn test() { foo.call(); }
-                   //^ {unknown}
+          //^^^^^^^^^^ {unknown}
 "#,
    );
 }
@@ -1016,7 +977,7 @@ where
    Wrapper<T>: a::Foo,
 {
    t.foo();
-}       //^ {unknown}
+} //^^^^^^^ {unknown}
 "#,
    );
 }
@@ -1033,7 +994,7 @@ impl A<i32> {
 fn main() {
    A::from(3);
-}          //^ A<i32>
+} //^^^^^^^^^^ A<i32>
 "#,
    );
 }
@@ -1061,7 +1022,7 @@ trait FnX {}
 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
 fn test() { (S {}).method(); }
-                        //^ ()
+          //^^^^^^^^^^^^^^^ ()
 "#,
    );
 }
@@ -1146,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
+    foo.into_vec(); // we shouldn't crash on this at least
-} //^ {unknown}
+} //^^^^^^^^^^^^^^ {unknown}
 "#,
    );
 }
@@ -1168,7 +1129,7 @@ impl dyn Foo + '_ {
 fn main() {
    let f = &42u32 as &dyn Foo;
    f.dyn_foo();
-  // ^u32
+ // ^^^^^^^^^^^ u32
 }
 "#,
    );
@@ -1178,11 +1139,7 @@ fn main() {
 fn autoderef_visibility_field() {
    check_infer(
        r#"
-#[lang = "deref"]
+//- minicore: deref
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
 mod a {
    pub struct Foo(pub char);
    pub struct Bar(i32);
@@ -1191,7 +1148,7 @@ mod a {
            Self(0)
        }
    }
-    impl super::Deref for Bar {
+    impl core::ops::Deref for Bar {
        type Target = Foo;
        fn deref(&self) -> &Foo {
            &Foo('z')
@@ -1205,22 +1162,21 @@ mod b {
 }
        "#,
        expect![[r#"
-            67..71 'self': &Self
+            107..138 '{     ...     }': Bar
-            200..231 '{     ...     }': Bar
+            121..125 'Self': Bar(i32) -> Bar
-            214..218 'Self': Bar(i32) -> Bar
+            121..128 'Self(0)': Bar
-            214..221 'Self(0)': Bar
+            126..127 '0': i32
-            219..220 '0': i32
+            226..230 'self': &Bar
-            315..319 'self': &Bar
+            240..273 '{     ...     }': &Foo
-            329..362 '{     ...     }': &Foo
+            254..263 '&Foo('z')': &Foo
-            343..352 '&Foo('z')': &Foo
+            255..258 'Foo': Foo(char) -> Foo
-            344..347 'Foo': Foo(char) -> Foo
+            255..263 'Foo('z')': Foo
-            344..352 'Foo('z')': Foo
+            259..262 ''z'': char
-            348..351 ''z'': char
+            303..350 '{     ...     }': ()
-            392..439 '{     ...     }': ()
+            317..318 'x': char
-            406..407 'x': char
+            321..339 'super:...r::new': fn new() -> Bar
-            410..428 'super:...r::new': fn new() -> Bar
+            321..341 'super:...:new()': Bar
-            410..430 'super:...:new()': Bar
+            321..343 'super:...ew().0': char
-            410..432 'super:...ew().0': char
        "#]],