22 files changed, 557 insertions, 601 deletions

diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 897da2832..bc58ce5fe 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -1,7 +1,7 @@
-use std::collections::HashMap;
+use itertools::Itertools;
+use rustc_hash::FxHashMap;
 
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
-use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
 
@@ -87,7 +87,7 @@ fn struct_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option
     }
 }
 
-fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<HashMap<String, usize>> {
+fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
     Some(
         struct_definition(path, &ctx.sema)?
             .fields(ctx.db)
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 27e94b7fe..e86077dd6 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -543,7 +543,7 @@ impl_froms!(Adt: Struct, Union, Enum);
 impl Adt {
     pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
         let subst = db.generic_defaults(self.into());
-        subst.iter().any(|ty| ty == &Ty::Unknown)
+        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
     }
 
     /// Turns this ADT into a type. Any type parameters of the ADT will be
@@ -775,7 +775,7 @@ pub struct TypeAlias {
 impl TypeAlias {
     pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
         let subst = db.generic_defaults(self.id.into());
-        subst.iter().any(|ty| ty == &Ty::Unknown)
+        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
     }
 
     pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -1035,7 +1035,10 @@ impl TypeParam {
         let local_idx = hir_ty::param_idx(db, self.id)?;
         let resolver = self.id.parent.resolver(db.upcast());
         let environment = TraitEnvironment::lower(db, &resolver);
-        params.get(local_idx).cloned().map(|ty| Type {
+        let ty = params.get(local_idx)?.clone();
+        let subst = Substs::type_params(db, self.id.parent);
+        let ty = ty.subst(&subst.prefix(local_idx));
+        Some(Type {
             krate: self.id.parent.module(db.upcast()).krate,
             ty: InEnvironment { value: ty, environment },
         })
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index 7889b8d2c..cad553273 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -14,7 +14,7 @@ use crate::{
     method_resolution::CrateImplDefs,
     traits::{chalk, AssocTyValue, Impl},
     Binders, CallableDef, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
-    ReturnTypeImplTraits, Substs, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
+    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
 };
 use hir_expand::name::Name;
 
@@ -65,7 +65,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
 
     #[salsa::invoke(crate::lower::generic_defaults_query)]
-    fn generic_defaults(&self, def: GenericDefId) -> Substs;
+    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
 
     #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_in_crate_query)]
     fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index 3c97e1354..23cea1a2a 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -308,7 +308,6 @@ impl HirDisplay for ApplicationTy {
                 }
 
                 if self.parameters.len() > 0 {
-                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
                     let parameters_to_write =
                         if f.display_target.is_source_code() || f.omit_verbose_types() {
                             match self
@@ -319,20 +318,23 @@ impl HirDisplay for ApplicationTy {
                             {
                                 None => self.parameters.0.as_ref(),
                                 Some(default_parameters) => {
+                                    let mut default_from = 0;
                                     for (i, parameter) in self.parameters.iter().enumerate() {
                                         match (parameter, default_parameters.get(i)) {
                                             (&Ty::Unknown, _) | (_, None) => {
-                                                non_default_parameters.push(parameter.clone())
+                                                default_from = i + 1;
                                             }
-                                            (_, Some(default_parameter))
-                                                if parameter != default_parameter =>
-                                            {
-                                                non_default_parameters.push(parameter.clone())
+                                            (_, Some(default_parameter)) => {
+                                                let actual_default = default_parameter
+                                                    .clone()
+                                                    .subst(&self.parameters.prefix(i));
+                                                if parameter != &actual_default {
+                                                    default_from = i + 1;
+                                                }
                                             }
-                                            _ => (),
                                         }
                                     }
-                                    &non_default_parameters
+                                    &self.parameters.0[0..default_from]
                                 }
                             }
                         } else {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index d5154f436..3dc154e92 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -578,11 +578,13 @@ fn substs_from_path_segment(
     // (i.e. defaults aren't used).
     if !infer_args || had_explicit_args {
         if let Some(def_generic) = def_generic {
-            let default_substs = ctx.db.generic_defaults(def_generic);
-            assert_eq!(total_len, default_substs.len());
+            let defaults = ctx.db.generic_defaults(def_generic);
+            assert_eq!(total_len, defaults.len());
 
-            for default_ty in default_substs.iter().skip(substs.len()) {
-                substs.push(default_ty.clone());
+            for default_ty in defaults.iter().skip(substs.len()) {
+                // each default can depend on the previous parameters
+                let substs_so_far = Substs(substs.clone().into());
+                substs.push(default_ty.clone().subst(&substs_so_far));
             }
         }
     }
@@ -945,17 +947,42 @@ pub(crate) fn generic_predicates_query(
 }
 
 /// Resolve the default type params from generics
-pub(crate) fn generic_defaults_query(db: &dyn HirDatabase, def: GenericDefId) -> Substs {
+pub(crate) fn generic_defaults_query(
+    db: &dyn HirDatabase,
+    def: GenericDefId,
+) -> Arc<[Binders<Ty>]> {
     let resolver = def.resolver(db.upcast());
-    let ctx = TyLoweringContext::new(db, &resolver);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
     let generic_params = generics(db.upcast(), def);
 
     let defaults = generic_params
         .iter()
-        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)))
+        .enumerate()
+        .map(|(idx, (_, p))| {
+            let mut ty = p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t));
+
+            // Each default can only refer to previous parameters.
+            ty.walk_mut_binders(
+                &mut |ty, binders| match ty {
+                    Ty::Bound(BoundVar { debruijn, index }) if *debruijn == binders => {
+                        if *index >= idx {
+                            // type variable default referring to parameter coming
+                            // after it. This is forbidden (FIXME: report
+                            // diagnostic)
+                            *ty = Ty::Unknown;
+                        }
+                    }
+                    _ => {}
+                },
+                DebruijnIndex::INNERMOST,
+            );
+
+            Binders::new(idx, ty)
+        })
         .collect();
 
-    Substs(defaults)
+    defaults
 }
 
 fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index 9c2c6959d..0481a7b12 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -154,6 +154,19 @@ impl TestDB {
         });
         (buf, count)
     }
+
+    pub fn all_files(&self) -> Vec<FileId> {
+        let mut res = Vec::new();
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                let file_id = crate_def_map[module_id].origin.file_id();
+                res.extend(file_id)
+            }
+        }
+        res
+    }
 }
 
 impl TestDB {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 2a85ce85d..5424e6bb1 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -17,17 +17,18 @@ use hir_def::{
     item_scope::ItemScope,
     keys,
     nameres::CrateDefMap,
-    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
+    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
 use insta::assert_snapshot;
-use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
+use ra_db::{fixture::WithFixture, salsa::Database, FileRange, SourceDatabase};
 use ra_syntax::{
     algo,
     ast::{self, AstNode},
     SyntaxNode,
 };
 use stdx::format_to;
+use test_utils::extract_annotations;
 
 use crate::{
     db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty,
@@ -37,21 +38,38 @@ use crate::{
 // against snapshots of the expected results using insta. Use cargo-insta to
 // update the snapshots.
 
-fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
-    type_at_pos_displayed(db, pos, |ty, _| ty.display(db).to_string())
+fn check_types(ra_fixture: &str) {
+    check_types_impl(ra_fixture, false)
 }
 
-fn displayed_source_at_pos(db: &TestDB, pos: FilePosition) -> String {
-    type_at_pos_displayed(db, pos, |ty, module_id| ty.display_source_code(db, module_id).unwrap())
+fn check_types_source_code(ra_fixture: &str) {
+    check_types_impl(ra_fixture, true)
 }
 
-fn type_at_pos_displayed(
-    db: &TestDB,
-    pos: FilePosition,
-    display_fn: impl FnOnce(&Ty, ModuleId) -> String,
-) -> String {
+fn check_types_impl(ra_fixture: &str, display_source: bool) {
+    let db = TestDB::with_files(ra_fixture);
+    let mut checked_one = false;
+    for file_id in db.all_files() {
+        let text = db.parse(file_id).syntax_node().to_string();
+        let annotations = extract_annotations(&text);
+        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(&db).to_string()
+            };
+            assert_eq!(expected, actual);
+            checked_one = true;
+        }
+    }
+    assert!(checked_one, "no `//^` annotations found");
+}
+
+fn type_at_range(db: &TestDB, pos: FileRange) -> Ty {
     let file = db.parse(pos.file_id).ok().unwrap();
-    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
+    let expr = algo::find_node_at_range::<ast::Expr>(file.syntax(), pos.range).unwrap();
     let fn_def = expr.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
     let module = db.module_for_file(pos.file_id);
     let func = *module.child_by_source(db)[keys::FUNCTION]
@@ -61,17 +79,11 @@ fn type_at_pos_displayed(
     let (_body, source_map) = db.body_with_source_map(func.into());
     if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
         let infer = db.infer(func.into());
-        let ty = &infer[expr_id];
-        return display_fn(ty, module);
+        return infer[expr_id].clone();
     }
     panic!("Can't find expression")
 }
 
-fn type_at(ra_fixture: &str) -> String {
-    let (db, file_pos) = TestDB::with_position(ra_fixture);
-    type_at_pos(&db, file_pos)
-}
-
 fn infer(ra_fixture: &str) -> String {
     infer_with_mismatches(ra_fixture, false)
 }
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 5a1c6ccc3..136d28a91 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -1,7 +1,8 @@
-use super::infer_with_mismatches;
 use insta::assert_snapshot;
 use test_utils::mark;
 
+use super::infer_with_mismatches;
+
 // Infer with some common definitions and impls.
 fn infer(source: &str) -> String {
     let defs = r#"
diff --git a/crates/ra_hir_ty/src/tests/display_source_code.rs b/crates/ra_hir_ty/src/tests/display_source_code.rs
index 5dfa0a014..b502135d8 100644
--- a/crates/ra_hir_ty/src/tests/display_source_code.rs
+++ b/crates/ra_hir_ty/src/tests/display_source_code.rs
@@ -1,50 +1,41 @@
-use super::displayed_source_at_pos;
-use crate::test_db::TestDB;
-use ra_db::fixture::WithFixture;
+use super::check_types_source_code;
 
 #[test]
 fn qualify_path_to_submodule() {
-    let (db, pos) = TestDB::with_position(
+    check_types_source_code(
         r#"
-//- /main.rs
-
 mod foo {
     pub struct Foo;
 }
 
 fn bar() {
     let foo: foo::Foo = foo::Foo;
-    foo<|>
-}
+    foo
+}  //^ foo::Foo
 
 "#,
     );
-    assert_eq!("foo::Foo", displayed_source_at_pos(&db, pos));
 }
 
 #[test]
 fn omit_default_type_parameters() {
-    let (db, pos) = TestDB::with_position(
-        r"
-        //- /main.rs
-        struct Foo<T = u8> { t: T }
-        fn main() {
-            let foo = Foo { t: 5u8 };
-            foo<|>;
-        }
-        ",
+    check_types_source_code(
+        r#"
+struct Foo<T = u8> { t: T }
+fn main() {
+    let foo = Foo { t: 5u8 };
+    foo;
+}  //^ Foo
+"#,
     );
-    assert_eq!("Foo", displayed_source_at_pos(&db, pos));
 
-    let (db, pos) = TestDB::with_position(
-        r"
-        //- /main.rs
-        struct Foo<K, T = u8> { k: K, t: T }
-        fn main() {
-            let foo = Foo { k: 400, t: 5u8 };
-            foo<|>;
-        }
-        ",
+    check_types_source_code(
+        r#"
+struct Foo<K, T = u8> { k: K, t: T }
+fn main() {
+    let foo = Foo { k: 400, t: 5u8 };
+    foo;
+}   //^ Foo<i32>
+"#,
     );
-    assert_eq!("Foo<i32>", displayed_source_at_pos(&db, pos));
 }
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index be2b48dcc..45c4e309e 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -1,16 +1,13 @@
 use std::fs;
 
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::project_dir;
 
-use crate::test_db::TestDB;
-
-use super::{infer, type_at, type_at_pos};
+use super::{check_types, infer};
 
 #[test]
 fn cfg_impl_def() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo cfg:test
 use foo::S as T;
@@ -28,8 +25,8 @@ impl S {
 
 fn test() {
     let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4());
-    t<|>;
-}
+    t;
+} //^ (i32, {unknown}, i32, {unknown})
 
 //- /foo.rs crate:foo
 struct S;
@@ -45,7 +42,6 @@ impl S {
 }
 "#,
     );
-    assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -253,26 +249,24 @@ fn foo() {
 
 #[test]
 fn processes_impls_generated_by_macros() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m {
     ($ident:ident) => (impl Trait for $ident {})
 }
 trait Trait { fn foo(self) -> u128 {} }
 struct S;
 m!(S);
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_assoc_items_generated_by_macros() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m {
     () => (fn foo(&self) -> u128 {0})
 }
@@ -281,17 +275,16 @@ impl S {
     m!();
 }
 
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_assoc_items_generated_by_macros_chain() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m_inner {
     () => {fn foo(&self) -> u128 {0}}
 }
@@ -304,21 +297,21 @@ impl S {
     m!();
 }
 
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_macro_with_dollar_crate_is_correct_in_expr() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 fn test() {
     let x = (foo::foo!(1), foo::foo!(2));
-    x<|>;
-}
+    x;
+} //^ (i32, usize)
 
 //- /lib.rs crate:foo
 #[macro_export]
@@ -335,12 +328,11 @@ macro_rules! bar {
 pub fn baz() -> usize { 31usize }
 "#,
     );
-    assert_eq!("(i32, usize)", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 use foo::Trait;
@@ -348,7 +340,8 @@ use foo::Trait;
 fn test() {
     let msg = foo::Message(foo::MessageRef);
     let r = msg.deref();
-    r<|>;
+    r;
+  //^ &MessageRef
 }
 
 //- /lib.rs crate:foo
@@ -375,7 +368,6 @@ macro_rules! expand {
 expand!();
 "#,
     );
-    assert_eq!("&MessageRef", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -429,13 +421,13 @@ fn main() {
 
 #[test]
 fn infer_local_inner_macros() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 fn test() {
     let x = foo::foo!(1);
-    x<|>;
-}
+    x;
+} //^ i32
 
 //- /lib.rs crate:foo
 #[macro_export(local_inner_macros)]
@@ -450,7 +442,6 @@ macro_rules! bar {
 
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -531,7 +522,7 @@ fn main() {
 
 #[test]
 fn infer_builtin_macros_include() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -540,14 +531,13 @@ macro_rules! include {() => {}}
 include!("foo.rs");
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -565,18 +555,17 @@ macro_rules! include {() => {}}
 include!("foo.rs");
 
 fn main() {
-    RegisterBlock { }<|>;
+    RegisterBlock { };
+                  //^ RegisterBlock
 }
     "#;
     let fixture = format!("{}\n//- /foo.rs\n{}", fixture, big_file);
-
-    let (db, pos) = TestDB::with_position(&fixture);
-    assert_eq!("RegisterBlock", type_at_pos(&db, pos));
+    check_types(&fixture);
 }
 
 #[test]
 fn infer_builtin_macros_include_concat() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -588,19 +577,18 @@ macro_rules! concat {() => {}}
 include!(concat!("f", "oo.rs"));
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_builtin_macros_include_concat_with_bad_env_should_failed() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -615,32 +603,29 @@ macro_rules! env {() => {}}
 include!(concat!(env!("OUT_DIR"), "/foo.rs"));
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ {unknown}
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("{unknown}", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_builtin_macros_include_itself_should_failed() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 #[rustc_builtin_macro]
 macro_rules! include {() => {}}
 
 include!("main.rs");
 
 fn main() {
-    0<|>
-}
+    0
+} //^ i32
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -686,14 +671,14 @@ fn main() {
 
 #[test]
 fn infer_derive_clone_simple() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 #[derive(Clone)]
 struct S;
 fn test() {
-    S.clone()<|>;
-}
+    S.clone();
+}         //^ S
 
 //- /lib.rs crate:core
 #[prelude_import]
@@ -705,12 +690,11 @@ mod clone {
 }
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_derive_clone_in_core() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /lib.rs crate:core
 #[prelude_import]
@@ -726,16 +710,15 @@ pub struct S;
 //- /main.rs crate:main deps:core
 use core::S;
 fn test() {
-    S.clone()<|>;
-}
+    S.clone();
+}         //^ S
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_derive_clone_with_params() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 #[derive(Clone)]
@@ -744,7 +727,8 @@ struct S;
 struct Wrapper<T>(T);
 struct NonClone;
 fn test() {
-    (Wrapper(S).clone(), Wrapper(NonClone).clone())<|>;
+    (Wrapper(S).clone(), Wrapper(NonClone).clone());
+  //^ (Wrapper<S>, {unknown})
 }
 
 //- /lib.rs crate:core
@@ -757,13 +741,12 @@ mod clone {
 }
 "#,
     );
-    assert_eq!("(Wrapper<S>, {unknown})", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_custom_derive_simple() {
     // FIXME: this test current now do nothing
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main
 use foo::Foo;
@@ -772,11 +755,10 @@ use foo::Foo;
 struct S{}
 
 fn test() {
-    S{}<|>;
-}
+    S{};
+}   //^ S
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index 20329bae4..9c8f22314 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -1,7 +1,6 @@
-use super::{infer, type_at, type_at_pos};
-use crate::test_db::TestDB;
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
+
+use super::{check_types, infer};
 
 #[test]
 fn infer_slice_method() {
@@ -246,13 +245,13 @@ fn test() {
 
 #[test]
 fn cross_crate_associated_method_call() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:other_crate
 fn test() {
     let x = other_crate::foo::S::thing();
-    x<|>;
-}
+    x;
+} //^ i128
 
 //- /lib.rs crate:other_crate
 mod foo {
@@ -263,7 +262,6 @@ mod foo {
 }
 "#,
     );
-    assert_eq!("i128", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -684,135 +682,127 @@ fn test() {
 
 #[test]
 fn method_resolution_unify_impl_self_type() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S<T>;
 impl S<u32> { fn foo(&self) -> u8 {} }
 impl S<i32> { fn foo(&self) -> i8 {} }
-fn test() { (S::<u32>.foo(), S::<i32>.foo())<|>; }
+fn test() { (S::<u32>.foo(), S::<i32>.foo()); }
+          //^ (u8, i8)
 "#,
     );
-    assert_eq!(t, "(u8, i8)");
 }
 
 #[test]
 fn method_resolution_trait_before_autoref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_by_value_before_autoref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone { fn clone(&self) -> Self; }
 struct S;
 impl Clone for S {}
 impl Clone for &S {}
-fn test() { (S.clone(), (&S).clone(), (&&S).clone())<|>; }
+fn test() { (S.clone(), (&S).clone(), (&&S).clone()); }
+          //^ (S, S, &S)
 "#,
     );
-    assert_eq!(t, "(S, S, &S)");
 }
 
 #[test]
 fn method_resolution_trait_before_autoderef() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_impl_before_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ i8
 "#,
     );
-    assert_eq!(t, "i8");
 }
 
 #[test]
 fn method_resolution_impl_ref_before_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ i8
 "#,
     );
-    assert_eq!(t, "i8");
 }
 
 #[test]
 fn method_resolution_trait_autoderef() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_unsize_array() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "slice"]
 impl<T> [T] {
     fn len(&self) -> usize { loop {} }
 }
 fn test() {
     let a = [1, 2, 3];
-    a.len()<|>;
-}
+    a.len();
+}       //^ usize
 "#,
     );
-    assert_eq!(t, "usize");
 }
 
 #[test]
 fn method_resolution_trait_from_prelude() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:other_crate
 struct S;
 impl Clone for S {}
 
 fn test() {
-    S.clone()<|>;
+    S.clone();
+          //^ S
 }
 
 //- /lib.rs crate:other_crate
@@ -825,115 +815,107 @@ mod foo {
 }
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn method_resolution_where_clause_for_unknown_trait() {
     // The blanket impl currently applies because we ignore the unresolved where clause
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: UnknownTrait {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_where_clause_not_met() {
     // The blanket impl shouldn't apply because we can't prove S: Clone
-    let t = type_at(
+    // This is also to make sure that we don't resolve to the foo method just
+    // because that's the only method named foo we can find, which would make
+    // the below tests not work
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: Clone {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ {unknown}
 "#,
     );
-    // This is also to make sure that we don't resolve to the foo method just
-    // because that's the only method named foo we can find, which would make
-    // the below tests not work
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_inline_not_met() {
     // The blanket impl shouldn't apply because we can't prove S: Clone
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T: Clone> Trait for T {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_where_clause_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Into<T> { fn into(self) -> T; }
 trait From<T> { fn from(other: T) -> Self; }
 struct S1;
 struct S2;
 impl From<S2> for S1 {}
 impl<T, U> Into<U> for T where U: From<T> {}
-fn test() { S2.into()<|>; }
+fn test() { S2.into(); }
+                  //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_inline() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Into<T> { fn into(self) -> T; }
 trait From<T> { fn from(other: T) -> Self; }
 struct S1;
 struct S2;
 impl From<S2> for S1 {}
 impl<T, U: From<T>> Into<U> for T {}
-fn test() { S2.into()<|>; }
+fn test() { S2.into(); }
+                  //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_overloaded_method() {
     test_utils::mark::check!(impl_self_type_match_without_receiver);
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Wrapper<T>(T);
 struct Foo<T>(T);
 struct Bar<T>(T);
@@ -953,30 +935,30 @@ impl<T> Wrapper<Bar<T>> {
 fn main() {
     let a = Wrapper::<Foo<f32>>::new(1.0);
     let b = Wrapper::<Bar<f32>>::new(1.0);
-    (a, b)<|>;
+    (a, b);
+  //^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)
 }
 "#,
     );
-    assert_eq!(t, "(Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)")
 }
 
 #[test]
 fn method_resolution_encountering_fn_type() {
-    type_at(
+    check_types(
         r#"
 //- /main.rs
 fn foo() {}
 trait FnOnce { fn call(self); }
-fn test() { foo.call()<|>; }
+fn test() { foo.call(); }
+                   //^ {unknown}
 "#,
     );
 }
 
 #[test]
 fn method_resolution_non_parameter_type() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 mod a {
     pub trait Foo {
         fn foo(&self);
@@ -988,18 +970,16 @@ fn foo<T>(t: Wrapper<T>)
 where
     Wrapper<T>: a::Foo,
 {
-    t.foo()<|>;
-}
+    t.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_3373() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct A<T>(T);
 
 impl A<i32> {
@@ -1007,19 +987,17 @@ impl A<i32> {
 }
 
 fn main() {
-    A::from(3)<|>;
-}
+    A::from(3);
+}          //^ A<i32>
 "#,
     );
-    assert_eq!(t, "A<i32>");
 }
 
 #[test]
 fn method_resolution_slow() {
     // this can get quite slow if we set the solver size limit too high
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait SendX {}
 
 struct S1; impl SendX for S1 {}
@@ -1037,10 +1015,10 @@ trait FnX {}
 
 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
 
-fn test() { (S {}).method()<|>; }
+fn test() { (S {}).method(); }
+                        //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/never_type.rs b/crates/ra_hir_ty/src/tests/never_type.rs
index ab9a990f5..64d421d40 100644
--- a/crates/ra_hir_ty/src/tests/never_type.rs
+++ b/crates/ra_hir_ty/src/tests/never_type.rs
@@ -1,99 +1,91 @@
 use insta::assert_snapshot;
 
-use super::{infer_with_mismatches, type_at};
+use super::{check_types, infer_with_mismatches};
 
 #[test]
 fn infer_never1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test() {
     let t = return;
-    t<|>;
-}
+    t;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn infer_never2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { a } else { loop {} };
-    a<|>;
-}
+    a;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn infer_never3() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { loop {} } else { a };
-    a<|>;
+    a;
+  //^ !
 }
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn never_type_in_generic_args() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
-}
+    a;
+} //^ Option<!>
 "#,
     );
-    assert_eq!(t, "Option<!>");
 }
 
 #[test]
 fn never_type_can_be_reinferred1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { loop {} } else { a };
-    a<|>;
+    a;
+  //^ ()
     if false { a };
 }
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn never_type_can_be_reinferred2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
+    a;
+  //^ Option<i32>
     match 42 {
         42 => a,
         _ => Option::Some(42),
@@ -101,19 +93,18 @@ fn test() {
 }
 "#,
     );
-    assert_eq!(t, "Option<i32>");
 }
 
 #[test]
 fn never_type_can_be_reinferred3() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
+    a;
+  //^ Option<&str>
     match 42 {
         42 => a,
         _ => Option::Some("str"),
@@ -121,82 +112,72 @@ fn test() {
 }
 "#,
     );
-    assert_eq!(t, "Option<&str>");
 }
 
 #[test]
 fn match_no_arm() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Void {}
 
 fn test(a: Void) {
     let t = match a {};
-    t<|>;
-}
+    t;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn match_unknown_arm() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: Option) {
     let t = match 0 {
         _ => unknown,
     };
-    t<|>;
-}
+    t;
+} //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn if_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test() {
     let i = if true {
         loop {}
     } else {
         3.0
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn if_else_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(input: bool) {
     let i = if input {
         2.0
     } else {
         return
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_first_arm_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         1 => return,
@@ -204,18 +185,16 @@ fn test(a: i32) {
         3 => loop {},
         _ => 3.0,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_second_arm_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         1 => 3.0,
@@ -223,45 +202,40 @@ fn test(a: i32) {
         3 => 3.0,
         _ => return,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_all_arms_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         2 => return,
         _ => loop {},
     };
-    i<|>;
-}
+    i;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn match_no_never_arms() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         2 => 2.0,
         _ => 3.0,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index aa37326df..d806e0ffb 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,10 +1,7 @@
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::mark;
 
-use crate::test_db::TestDB;
-
-use super::infer;
+use super::{check_types, infer};
 
 #[test]
 fn bug_484() {
@@ -404,13 +401,13 @@ fn test() {
 
 #[test]
 fn issue_2683_chars_impl() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 fn test() {
     let chars: std::str::Chars<'_>;
-    (chars.next(), chars.nth(1))<|>;
-}
+    (chars.next(), chars.nth(1));
+} //^ (Option<char>, Option<char>)
 
 //- /std.rs crate:std
 #[prelude_import]
@@ -449,15 +446,12 @@ pub mod str {
 }
 "#,
     );
-
-    assert_eq!("(Option<char>, Option<char>)", super::type_at_pos(&db, pos));
 }
 
 #[test]
 fn issue_3642_bad_macro_stackover() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 #[macro_export]
 macro_rules! match_ast {
     (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
@@ -472,7 +466,8 @@ macro_rules! match_ast {
 }
 
 fn main() {
-    let anchor<|> = match_ast! {
+    let anchor = match_ast! {
+       //^ ()
         match parent {
             as => {},
             _ => return None
@@ -480,8 +475,6 @@ fn main() {
     };
 }"#,
     );
-
-    assert_eq!("()", super::type_at_pos(&db, pos));
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index cd919466f..de63f4cce 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1,19 +1,17 @@
-use super::{infer, type_at, type_at_pos};
-use crate::test_db::TestDB;
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
+
+use super::{check_types, infer};
 
 #[test]
 fn infer_box() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 fn test() {
     let x = box 1;
     let t = (x, box x, box &1, box [1]);
-    t<|>;
-}
+    t;
+} //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)
 
 //- /std.rs crate:std
 #[prelude_import] use prelude::*;
@@ -25,29 +23,24 @@ mod boxed {
         inner: *mut T,
     }
 }
-
 "#,
     );
-    assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_adt_self() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 enum Nat { Succ(Self), Demo(Nat), Zero }
 
 fn test() {
     let foo: Nat = Nat::Zero;
     if let Nat::Succ(x) = foo {
-        x<|>
-    }
+        x
+    } //^ Nat
 }
-
 "#,
     );
-    assert_eq!("Nat", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -93,7 +86,7 @@ fn foo() {
 
 #[test]
 fn infer_ranges() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 fn test() {
@@ -105,8 +98,8 @@ fn test() {
     let f = 'a'..='z';
 
     let t = (a, b, c, d, e, f);
-    t<|>;
-}
+    t;
+} //^ (RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)
 
 //- /core.rs crate:core
 #[prelude_import] use prelude::*;
@@ -135,29 +128,22 @@ pub mod ops {
 }
 "#,
     );
-    assert_eq!(
-        "(RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)",
-        type_at_pos(&db, pos),
-    );
 }
 
 #[test]
 fn infer_while_let() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { Some(T), None }
 
 fn test() {
     let foo: Option<f32> = None;
     while let Option::Some(x) = foo {
-        <|>x
-    }
+        x
+    } //^ f32
 }
-
 "#,
     );
-    assert_eq!("f32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -1687,9 +1673,8 @@ fn test() {
 
 #[test]
 fn shadowing_primitive() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct i32;
 struct Foo;
 
@@ -1697,15 +1682,15 @@ impl i32 { fn foo(&self) -> Foo { Foo } }
 
 fn main() {
     let x: i32 = i32;
-    x.foo()<|>;
+    x.foo();
+        //^ Foo
 }"#,
     );
-    assert_eq!(t, "Foo");
 }
 
 #[test]
 fn not_shadowing_primitive_by_module() {
-    let t = type_at(
+    check_types(
         r#"
 //- /str.rs
 fn foo() {}
@@ -1715,15 +1700,15 @@ mod str;
 fn foo() -> &'static str { "" }
 
 fn main() {
-    foo()<|>;
+    foo();
+      //^ &str
 }"#,
     );
-    assert_eq!(t, "&str");
 }
 
 #[test]
 fn not_shadowing_module_by_primitive() {
-    let t = type_at(
+    check_types(
         r#"
 //- /str.rs
 fn foo() -> u32 {0}
@@ -1733,10 +1718,10 @@ mod str;
 fn foo() -> &'static str { "" }
 
 fn main() {
-    str::foo()<|>;
+    str::foo();
+           //^ u32
 }"#,
     );
-    assert_eq!(t, "u32");
 }
 
 // This test is actually testing the shadowing behavior within ra_hir_def. It
@@ -1744,27 +1729,7 @@ fn main() {
 // capable of asserting the necessary conditions.
 #[test]
 fn should_be_shadowing_imports() {
-    let t = type_at(
-        r#"
-mod a {
-    pub fn foo() -> i8 {0}
-    pub struct foo { a: i8 }
-}
-mod b { pub fn foo () -> u8 {0} }
-mod c { pub struct foo { a: u8 } }
-mod d {
-    pub use super::a::*;
-    pub use super::c::foo;
-    pub use super::b::foo;
-}
-
-fn main() {
-    d::foo()<|>;
-}"#,
-    );
-    assert_eq!(t, "u8");
-
-    let t = type_at(
+    check_types(
         r#"
 mod a {
     pub fn foo() -> i8 {0}
@@ -1779,10 +1744,12 @@ mod d {
 }
 
 fn main() {
-    d::foo{a:0<|>};
+    d::foo();
+         //^ u8
+    d::foo{a:0};
+           //^ u8
 }"#,
     );
-    assert_eq!(t, "u8");
 }
 
 #[test]
@@ -2152,3 +2119,48 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn generic_default_depending_on_other_type_arg() {
+    assert_snapshot!(
+        infer(r#"
+struct Thing<T = u128, F = fn() -> T> { t: T }
+
+fn test(t1: Thing<u32>, t2: Thing) {
+    t1;
+    t2;
+    Thing::<_> { t: 1u32 };
+}
+"#),
+        // FIXME: the {unknown} is a bug
+        @r###"
+    56..58 't1': Thing<u32, fn() -> u32>
+    72..74 't2': Thing<u128, fn() -> u128>
+    83..130 '{     ...2 }; }': ()
+    89..91 't1': Thing<u32, fn() -> u32>
+    97..99 't2': Thing<u128, fn() -> u128>
+    105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}>
+    121..125 '1u32': u32
+    "###
+    );
+}
+
+#[test]
+fn generic_default_depending_on_other_type_arg_forward() {
+    assert_snapshot!(
+        infer(r#"
+struct Thing<F = fn() -> T, T = u128> { t: T }
+
+fn test(t1: Thing) {
+    t1;
+}
+"#),
+        // the {unknown} here is intentional, as defaults are not allowed to
+        // refer to type parameters coming later
+        @r###"
+    56..58 't1': Thing<fn() -> {unknown}, u128>
+    67..78 '{     t1; }': ()
+    73..75 't1': Thing<fn() -> {unknown}, u128>
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 71c0c2d27..01c919a7e 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,17 +1,13 @@
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::mark;
 
-use crate::test_db::TestDB;
-
-use super::{infer, infer_with_mismatches, type_at, type_at_pos};
+use super::{check_types, infer, infer_with_mismatches};
 
 #[test]
 fn infer_await() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 struct IntFuture;
 
 impl Future for IntFuture {
@@ -21,8 +17,8 @@ impl Future for IntFuture {
 fn test() {
     let r = IntFuture;
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -32,18 +28,15 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 async fn foo() -> u64 {
     128
 }
@@ -51,8 +44,8 @@ async fn foo() -> u64 {
 fn test() {
     let r = foo();
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -62,26 +55,23 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_desugar_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 async fn foo() -> u64 {
     128
 }
 
 fn test() {
     let r = foo();
-    r<|>;
-}
+    r;
+} //^ impl Future<Output = u64>
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -93,23 +83,20 @@ mod future {
 
 "#,
     );
-    assert_eq!("impl Future<Output = u64>", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_try() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 fn test() {
     let r: Result<i32, u64> = Result::Ok(1);
     let v = r?;
-    v<|>;
-}
+    v;
+} //^ i32
 
 //- /core.rs crate:core
-
 #[prelude_import] use ops::*;
 mod ops {
     trait Try {
@@ -130,30 +117,26 @@ mod result {
         type Error = E;
     }
 }
-
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_for_loop() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core,alloc
-
 use alloc::collections::Vec;
 
 fn test() {
     let v = Vec::new();
     v.push("foo");
     for x in v {
-        x<|>;
-    }
+        x;
+    } //^ &str
 }
 
 //- /core.rs crate:core
-
 #[prelude_import] use iter::*;
 mod iter {
     trait IntoIterator {
@@ -162,7 +145,6 @@ mod iter {
 }
 
 //- /alloc.rs crate:alloc deps:core
-
 mod collections {
     struct Vec<T> {}
     impl<T> Vec<T> {
@@ -176,15 +158,13 @@ mod collections {
 }
 "#,
     );
-    assert_eq!("&str", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_neg() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -195,11 +175,10 @@ impl std::ops::Neg for Bar {
 fn test() {
     let a = Bar;
     let b = -a;
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
-
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "neg"]
@@ -209,15 +188,13 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_not() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -228,11 +205,10 @@ impl std::ops::Not for Bar {
 fn test() {
     let a = Bar;
     let b = !a;
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
-
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "not"]
@@ -242,7 +218,6 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -537,10 +512,9 @@ fn indexing_arrays() {
 
 #[test]
 fn infer_ops_index() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -551,11 +525,10 @@ impl std::ops::Index<u32> for Bar {
 fn test() {
     let a = Bar;
     let b = a[1u32];
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
-
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "index"]
@@ -565,19 +538,18 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_index_autoderef() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 fn test() {
     let a = &[1u32, 2, 3];
     let b = a[1u32];
-    b<|>;
-}
+    b;
+} //^ u32
 
 //- /std.rs crate:std
 impl<T> ops::Index<u32> for [T] {
@@ -593,14 +565,12 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn deref_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -618,16 +588,15 @@ impl S {
 }
 
 fn test(s: Arc<S>) {
-    (*s, s.foo())<|>;
-}
+    (*s, s.foo());
+} //^ (S, u128)
 "#,
     );
-    assert_eq!(t, "(S, u128)");
 }
 
 #[test]
 fn deref_trait_with_inference_var() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 #[lang = "deref"]
@@ -647,19 +616,18 @@ fn foo(a: Arc<S>) {}
 
 fn test() {
     let a = new_arc();
-    let b = (*a)<|>;
+    let b = (*a);
+          //^ S
     foo(a);
 }
 "#,
     );
-    assert_eq!(t, "S");
 }
 
 #[test]
 fn deref_trait_infinite_recursion() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -673,18 +641,16 @@ impl Deref for S {
 }
 
 fn test(s: S) {
-    s.foo()<|>;
-}
+    s.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn deref_trait_with_question_mark_size() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -702,18 +668,16 @@ impl S {
 }
 
 fn test(s: Arc<S>) {
-    (*s, s.foo())<|>;
-}
+    (*s, s.foo());
+} //^ (S, u128)
 "#,
     );
-    assert_eq!(t, "(S, u128)");
 }
 
 #[test]
 fn obligation_from_function_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -722,16 +686,15 @@ impl Trait<u32> for S {}
 fn foo<T: Trait<U>, U>(t: T) -> U {}
 
 fn test(s: S) {
-    foo(s)<|>;
-}
+    (foo(s));
+} //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn obligation_from_method_clause() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 struct S;
@@ -745,18 +708,16 @@ impl O {
 }
 
 fn test() {
-    O.foo(S)<|>;
-}
+    O.foo(S);
+}      //^ isize
 "#,
     );
-    assert_eq!(t, "isize");
 }
 
 #[test]
 fn obligation_from_self_method_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -767,18 +728,16 @@ impl S {
 }
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ i64
 "#,
     );
-    assert_eq!(t, "i64");
 }
 
 #[test]
 fn obligation_from_impl_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -790,32 +749,30 @@ impl<U, T: Trait<U>> O<T> {
 }
 
 fn test(o: O<S>) {
-    o.foo()<|>;
-}
+    o.foo();
+}       //^ &str
 "#,
     );
-    assert_eq!(t, "&str");
 }
 
 #[test]
 fn generic_param_env_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test<T: Clone>(t: T) { t.foo()<|>; }
+fn test<T: Clone>(t: T) { t.foo(); }
+                             //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn generic_param_env_1_not_met() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 trait Clone {}
@@ -823,45 +780,42 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test<T>(t: T) { t.foo()<|>; }
+fn test<T>(t: T) { t.foo(); }
+                       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn generic_param_env_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
-fn test<T: Trait>(t: T) { t.foo()<|>; }
+fn test<T: Trait>(t: T) { t.foo(); }
+                              //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn generic_param_env_2_not_met() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
-fn test<T>(t: T) { t.foo()<|>; }
+fn test<T>(t: T) { t.foo(); }
+                       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn generic_param_env_deref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -870,17 +824,17 @@ trait Trait {}
 impl<T> Deref for T where T: Trait {
     type Target = i128;
 }
-fn test<T: Trait>(t: T) { (*t)<|>; }
+fn test<T: Trait>(t: T) { (*t); }
+                        //^ i128
 "#,
     );
-    assert_eq!(t, "i128");
 }
 
 #[test]
 fn associated_type_placeholder() {
-    let t = type_at(
+    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
+    check_types(
         r#"
-//- /main.rs
 pub trait ApplyL {
     type Out;
 }
@@ -893,19 +847,16 @@ impl<T> ApplyL for RefMutL<T> {
 
 fn test<T: ApplyL>() {
     let y: <RefMutL<T> as ApplyL>::Out = no_matter;
-    y<|>;
-}
+    y;
+} //^ ApplyL::Out<T>
 "#,
     );
-    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
-    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
 fn associated_type_placeholder_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 pub trait ApplyL {
     type Out;
 }
@@ -913,11 +864,10 @@ fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
 
 fn test<T: ApplyL>(t: T) {
     let y = foo(t);
-    y<|>;
-}
+    y;
+} //^ ApplyL::Out<T>
 "#,
     );
-    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
@@ -1398,19 +1348,17 @@ fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl (
 #[test]
 #[ignore]
 fn error_bound_chalk() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     fn foo(&self) -> u32 {}
 }
 
 fn test(x: (impl Trait + UnknownTrait)) {
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -1480,7 +1428,7 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
 
 #[test]
 fn impl_trait_assoc_binding_projection_bug() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 pub trait Language {
@@ -1499,8 +1447,8 @@ trait Clone {
 
 fn api_walkthrough() {
     for node in foo() {
-        node.clone()<|>;
-    }
+        node.clone();
+    }            //^ {unknown}
 }
 
 //- /std.rs crate:std
@@ -1518,7 +1466,6 @@ mod iter {
 }
 "#,
     );
-    assert_eq!("{unknown}", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -1549,9 +1496,8 @@ fn test<T: Trait1<Type = u32>>(x: T) {
 
 #[test]
 fn where_clause_trait_in_scope_for_method_resolution() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 mod foo {
     trait Trait {
         fn foo(&self) -> u32 {}
@@ -1559,11 +1505,10 @@ mod foo {
 }
 
 fn test<T: foo::Trait>(x: T) {
-    x.foo()<|>;
-}
+    x.foo();
+}      //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -2012,7 +1957,7 @@ fn test() {
 
 #[test]
 fn unselected_projection_in_trait_env_1() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 trait Trait {
@@ -2025,18 +1970,16 @@ trait Trait2 {
 
 fn test<T: Trait>() where T::Item: Trait2 {
     let x: T::Item = no_matter;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait<T> {
     type Item;
 }
@@ -2047,11 +1990,10 @@ trait Trait2 {
 
 fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
     let x: T::Item = no_matter;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -2097,9 +2039,8 @@ impl Trait for S2 {
 
 #[test]
 fn unselected_projection_on_trait_self() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     type Item;
 
@@ -2112,18 +2053,16 @@ impl Trait for S {
 }
 
 fn test() {
-    S.f()<|>;
-}
+    S.f();
+}     //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn unselected_projection_chalk_fold() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Interner {}
 trait Fold<I: Interner, TI = I> {
     type Result;
@@ -2142,18 +2081,16 @@ where
 }
 
 fn foo<I: Interner>(interner: &I, t: Ty<I>) {
-    fold(interner, t)<|>;
-}
+    fold(interner, t);
+}     //^ Ty<I>
 "#,
     );
-    assert_eq!(t, "Ty<I>");
 }
 
 #[test]
 fn trait_impl_self_ty() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait<T> {
    fn foo(&self);
 }
@@ -2163,18 +2100,16 @@ struct S;
 impl Trait<Self> for S {}
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn trait_impl_self_ty_cycle() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
    fn foo(&self);
 }
@@ -2184,18 +2119,17 @@ struct S<T>;
 impl Trait for S<Self> {}
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_cycle_1() {
-    let t = type_at(
+    // this is a legitimate cycle
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     type Item;
 }
@@ -2203,17 +2137,16 @@ trait Trait {
 trait Trait2<T> {}
 
 fn test<T: Trait>() where T: Trait2<T::Item> {
-    let x: T::Item = no_matter<|>;
-}
+    let x: T::Item = no_matter;
+}                       //^ {unknown}
 "#,
     );
-    // this is a legitimate cycle
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_cycle_2() {
-    let t = type_at(
+    // this is a legitimate cycle
+    check_types(
         r#"
 //- /main.rs
 trait Trait<T> {
@@ -2221,19 +2154,16 @@ trait Trait<T> {
 }
 
 fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
-    let x: T::Item = no_matter<|>;
-}
+    let x: T::Item = no_matter;
+}                   //^ {unknown}
 "#,
     );
-    // this is a legitimate cycle
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn inline_assoc_type_bounds_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Iterator {
     type Item;
 }
@@ -2249,29 +2179,26 @@ impl<T: Iterator> Iterator for S<T> {
 
 fn test<I: Iterator<Item: OtherTrait<u32>>>() {
     let x: <S<I> as Iterator>::Item;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn inline_assoc_type_bounds_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Iterator {
     type Item;
 }
 
 fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
     let x: <<I as Iterator>::Item as Iterator>::Item;
-    x<|>;
-}
+    x;
+} //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -2445,9 +2372,8 @@ fn main() {
 
 #[test]
 fn associated_type_bound() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 pub trait Trait {
     type Item: OtherTrait<u32>;
 }
@@ -2463,18 +2389,16 @@ impl<T: Trait> Trait for S<T> {
 
 fn test<T: Trait>() {
     let y: <S<T> as Trait>::Item = no_matter;
-    y.foo()<|>;
-}
+    y.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn dyn_trait_through_chalk() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Box<T> {}
 #[lang = "deref"]
 trait Deref {
@@ -2488,18 +2412,16 @@ trait Trait {
 }
 
 fn test(x: Box<dyn Trait>) {
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn string_to_owned() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct String {}
 pub trait ToOwned {
     type Owned;
@@ -2509,11 +2431,10 @@ impl ToOwned for str {
     type Owned = String;
 }
 fn test() {
-    "foo".to_owned()<|>;
-}
+    "foo".to_owned();
+}               //^ String
 "#,
     );
-    assert_eq!(t, "String");
 }
 
 #[test]
@@ -2637,9 +2558,8 @@ fn main() {
 
 #[test]
 fn nested_assoc() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Bar;
 struct Foo;
 
@@ -2662,11 +2582,10 @@ impl<T:A> B for T {
 }
 
 fn main() {
-    Bar::foo()<|>;
-}
+    Bar::foo();
+}          //^ Foo
 "#,
     );
-    assert_eq!(t, "Foo");
 }
 
 #[test]
@@ -2846,12 +2765,12 @@ fn test() {
 
 #[test]
 fn integer_range_iterate() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 fn test() {
-    for x in 0..100 { x<|>; }
-}
+    for x in 0..100 { x; }
+}                   //^ i32
 
 //- /core.rs crate:core
 pub mod ops {
@@ -2886,7 +2805,6 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
 }
 "#,
     );
-    assert_eq!(t, "i32");
 }
 
 #[test]
diff --git a/crates/ra_ssr/src/parsing.rs b/crates/ra_ssr/src/parsing.rs
index 90c13dbc2..1ae166d19 100644
--- a/crates/ra_ssr/src/parsing.rs
+++ b/crates/ra_ssr/src/parsing.rs
@@ -165,7 +165,7 @@ fn parse_pattern(pattern_str: &str) -> Result<Vec<PatternElement>, SsrError> {
 /// Checks for errors in a rule. e.g. the replace pattern referencing placeholders that the search
 /// pattern didn't define.
 fn validate_rule(rule: &SsrRule) -> Result<(), SsrError> {
-    let mut defined_placeholders = std::collections::HashSet::new();
+    let mut defined_placeholders = FxHashSet::default();
     for p in &rule.pattern.raw.tokens {
         if let PatternElement::Placeholder(placeholder) = p {
             defined_placeholders.insert(&placeholder.ident);
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index f7a885eb3..26b3c813a 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -41,6 +41,10 @@ pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextSize) ->
     ancestors_at_offset(syntax, offset).find_map(N::cast)
 }
 
+pub fn find_node_at_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
+    find_covering_element(syntax, range).ancestors().find_map(N::cast)
+}
+
 /// Skip to next non `trivia` token
 pub fn skip_trivia_token(mut token: SyntaxToken, direction: Direction) -> Option<SyntaxToken> {
     while token.kind().is_trivia() {
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 2f4c29e06..9d09501cd 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -1,7 +1,11 @@
 //! Fully type-check project and print various stats, like the number of type
 //! errors.
 
-use std::{collections::HashSet, path::Path, time::Instant};
+use std::{path::Path, time::Instant};
+
+use itertools::Itertools;
+use rand::{seq::SliceRandom, thread_rng};
+use rustc_hash::FxHashSet;
 
 use hir::{
     db::{AstDatabase, DefDatabase, HirDatabase},
@@ -9,10 +13,8 @@ use hir::{
 };
 use hir_def::FunctionId;
 use hir_ty::{Ty, TypeWalk};
-use itertools::Itertools;
 use ra_db::SourceDatabaseExt;
 use ra_syntax::AstNode;
-use rand::{seq::SliceRandom, thread_rng};
 use stdx::format_to;
 
 use crate::cli::{load_cargo::load_cargo, progress_report::ProgressReport, Result, Verbosity};
@@ -33,7 +35,7 @@ pub fn analysis_stats(
     println!("Database loaded {:?}", db_load_time.elapsed());
     let analysis_time = Instant::now();
     let mut num_crates = 0;
-    let mut visited_modules = HashSet::new();
+    let mut visited_modules = FxHashSet::default();
     let mut visit_queue = Vec::new();
 
     let mut krates = Crate::all(db);
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 82b3a8a53..6f3c1c1f9 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -1,11 +1,14 @@
 //! Analyze all modules in a project for diagnostics. Exits with a non-zero status
 //! code if any errors are found.
 
+use std::path::Path;
+
 use anyhow::anyhow;
+use rustc_hash::FxHashSet;
+
 use hir::Crate;
 use ra_db::SourceDatabaseExt;
 use ra_ide::Severity;
-use std::{collections::HashSet, path::Path};
 
 use crate::cli::{load_cargo::load_cargo, Result};
 
@@ -20,7 +23,7 @@ pub fn diagnostics(
     let analysis = host.analysis();
 
     let mut found_error = false;
-    let mut visited_files = HashSet::new();
+    let mut visited_files = FxHashSet::default();
 
     let mut work = Vec::new();
     let krates = Crate::all(db);
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index 1cf50b677..b46281c98 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -1,14 +1,14 @@
 //! Book keeping for keeping diagnostics easily in sync with the client.
 pub(crate) mod to_proto;
 
-use std::{collections::HashMap, mem, sync::Arc};
+use std::{mem, sync::Arc};
 
 use ra_ide::FileId;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::lsp_ext;
 
-pub(crate) type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
+pub(crate) type CheckFixes = Arc<FxHashMap<FileId, Vec<Fix>>>;
 
 #[derive(Debug, Default, Clone)]
 pub struct DiagnosticsConfig {
@@ -18,8 +18,8 @@ pub struct DiagnosticsConfig {
 
 #[derive(Debug, Default, Clone)]
 pub(crate) struct DiagnosticCollection {
-    pub(crate) native: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
-    pub(crate) check: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
+    pub(crate) native: FxHashMap<FileId, Vec<lsp_types::Diagnostic>>,
+    pub(crate) check: FxHashMap<FileId, Vec<lsp_types::Diagnostic>>,
     pub(crate) check_fixes: CheckFixes,
     changes: FxHashSet<FileId>,
 }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index eaeeeb97b..caf847273 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -16,6 +16,7 @@ use std::{
 };
 
 use serde_json::Value;
+use stdx::lines_with_ends;
 use text_size::{TextRange, TextSize};
 
 pub use difference::Changeset as __Changeset;
@@ -159,6 +160,41 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
     res
 }
 
+/// Extracts `//^ some text` annotations
+pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
+    let mut res = Vec::new();
+    let mut prev_line_start: Option<TextSize> = None;
+    let mut line_start: TextSize = 0.into();
+    for line in lines_with_ends(text) {
+        if let Some(idx) = line.find("//^") {
+            let offset = prev_line_start.unwrap() + TextSize::of(&line[..idx + "//".len()]);
+            let data = line[idx + "//^".len()..].trim().to_string();
+            res.push((TextRange::at(offset, 1.into()), data))
+        }
+        prev_line_start = Some(line_start);
+        line_start += TextSize::of(line);
+    }
+    res
+}
+
+#[test]
+fn test_extract_annotations() {
+    let text = stdx::trim_indent(
+        r#"
+fn main() {
+    let x = 92;
+      //^ def
+    z + 1
+} //^ i32
+    "#,
+    );
+    let res = extract_annotations(&text)
+        .into_iter()
+        .map(|(range, ann)| (&text[range], ann))
+        .collect::<Vec<_>>();
+    assert_eq!(res, vec![("x", "def".into()), ("z", "i32".into()),]);
+}
+
 // Comparison functionality borrowed from cargo:
 
 /// Compare a line with an expected pattern.
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 11dc5261b..6b6824ded 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -254,6 +254,11 @@ The default name is a lowercased name of the type: `global_state: GlobalState`.
 Avoid ad-hoc acronyms and contractions, but use the ones that exist consistently (`db`, `ctx`, `acc`).
 The default name for "result of the function" local variable is `res`.
 
+## Collection types
+
+We prefer `rustc_hash::FxHashMap` and `rustc_hash::FxHashSet` instead of the ones in `std::collections`.
+They use a hasher that's slightly faster and using them consistently will reduce code size by some small amount.
+
 ## Preconditions
 
 Function preconditions should generally be expressed in types and provided by the caller (rather than checked by callee):