327 files changed, 5756 insertions, 3117 deletions

diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 0d2109e4e..6973038d4 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -16,6 +16,8 @@ either = "1.5"
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_fmt = { path = "../ra_fmt" }
+ra_prof = { path = "../ra_prof" }
 ra_db = { path = "../ra_db" }
+ra_ide_db = { path = "../ra_ide_db" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 43f0d664b..5aab5fb8b 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,8 +1,8 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use either::Either;
-use hir::{db::HirDatabase, InFile, SourceAnalyzer, SourceBinder};
-use ra_db::FileRange;
+use hir::{InFile, SourceAnalyzer, SourceBinder};
+use ra_db::{FileRange, SourceDatabase};
 use ra_fmt::{leading_indent, reindent};
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{self, find_covering_element, find_node_at_offset},
     AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextUnit,
@@ -10,14 +10,40 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
 
-use crate::{AssistAction, AssistId, AssistLabel, ResolvedAssist};
+use crate::{AssistAction, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
 
 #[derive(Clone, Debug)]
-pub(crate) enum Assist {
-    Unresolved { label: AssistLabel },
-    Resolved { assist: ResolvedAssist },
+pub(crate) struct Assist(pub(crate) Vec<AssistInfo>);
+
+#[derive(Clone, Debug)]
+pub(crate) struct AssistInfo {
+    pub(crate) label: AssistLabel,
+    pub(crate) group_label: Option<GroupLabel>,
+    pub(crate) action: Option<AssistAction>,
+}
+
+impl AssistInfo {
+    fn new(label: AssistLabel) -> AssistInfo {
+        AssistInfo { label, group_label: None, action: None }
+    }
+
+    fn resolved(self, action: AssistAction) -> AssistInfo {
+        AssistInfo { action: Some(action), ..self }
+    }
+
+    fn with_group(self, group_label: GroupLabel) -> AssistInfo {
+        AssistInfo { group_label: Some(group_label), ..self }
+    }
+
+    pub(crate) fn into_resolved(self) -> Option<ResolvedAssist> {
+        let label = self.label;
+        let group_label = self.group_label;
+        self.action.map(|action| ResolvedAssist { label, group_label, action })
+    }
 }
 
+pub(crate) type AssistHandler = fn(AssistCtx) -> Option<Assist>;
+
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
 ///
 /// Assists use a somewhat over-engineered approach, given the current needs. The
@@ -49,14 +75,14 @@ pub(crate) enum Assist {
 /// moment, because the LSP API is pretty awkward in this place, and it's much
 /// easier to just compute the edit eagerly :-)
 #[derive(Debug)]
-pub(crate) struct AssistCtx<'a, DB> {
-    pub(crate) db: &'a DB,
+pub(crate) struct AssistCtx<'a> {
+    pub(crate) db: &'a RootDatabase,
     pub(crate) frange: FileRange,
     source_file: SourceFile,
     should_compute_edit: bool,
 }
 
-impl<'a, DB> Clone for AssistCtx<'a, DB> {
+impl Clone for AssistCtx<'_> {
     fn clone(&self) -> Self {
         AssistCtx {
             db: self.db,
@@ -67,15 +93,10 @@ impl<'a, DB> Clone for AssistCtx<'a, DB> {
     }
 }
 
-impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
-    pub(crate) fn with_ctx<F, T>(db: &DB, frange: FileRange, should_compute_edit: bool, f: F) -> T
-    where
-        F: FnOnce(AssistCtx<DB>) -> T,
-    {
+impl<'a> AssistCtx<'a> {
+    pub fn new(db: &RootDatabase, frange: FileRange, should_compute_edit: bool) -> AssistCtx {
         let parse = db.parse(frange.file_id);
-
-        let ctx = AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit };
-        f(ctx)
+        AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit }
     }
 
     pub(crate) fn add_assist(
@@ -84,48 +105,23 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
         label: impl Into<String>,
         f: impl FnOnce(&mut ActionBuilder),
     ) -> Option<Assist> {
-        let label = AssistLabel { label: label.into(), id };
-        assert!(label.label.chars().nth(0).unwrap().is_uppercase());
+        let label = AssistLabel::new(label.into(), id);
 
-        let assist = if self.should_compute_edit {
+        let mut info = AssistInfo::new(label);
+        if self.should_compute_edit {
             let action = {
                 let mut edit = ActionBuilder::default();
                 f(&mut edit);
                 edit.build()
             };
-            Assist::Resolved { assist: ResolvedAssist { label, action_data: Either::Left(action) } }
-        } else {
-            Assist::Unresolved { label }
+            info = info.resolved(action)
         };
 
-        Some(assist)
+        Some(Assist(vec![info]))
     }
 
-    #[allow(dead_code)] // will be used for auto import assist with multiple actions
-    pub(crate) fn add_assist_group(
-        self,
-        id: AssistId,
-        label: impl Into<String>,
-        f: impl FnOnce() -> Vec<ActionBuilder>,
-    ) -> Option<Assist> {
-        let label = AssistLabel { label: label.into(), id };
-        let assist = if self.should_compute_edit {
-            let actions = f();
-            assert!(!actions.is_empty(), "Assist cannot have no");
-
-            Assist::Resolved {
-                assist: ResolvedAssist {
-                    label,
-                    action_data: Either::Right(
-                        actions.into_iter().map(ActionBuilder::build).collect(),
-                    ),
-                },
-            }
-        } else {
-            Assist::Unresolved { label }
-        };
-
-        Some(assist)
+    pub(crate) fn add_assist_group(self, group_name: impl Into<String>) -> AssistGroup<'a> {
+        AssistGroup { ctx: self, group_name: group_name.into(), assists: Vec::new() }
     }
 
     pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
@@ -142,7 +138,7 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
     pub(crate) fn covering_element(&self) -> SyntaxElement {
         find_covering_element(self.source_file.syntax(), self.frange.range)
     }
-    pub(crate) fn source_binder(&self) -> SourceBinder<'a, DB> {
+    pub(crate) fn source_binder(&self) -> SourceBinder<'a, RootDatabase> {
         SourceBinder::new(self.db)
     }
     pub(crate) fn source_analyzer(
@@ -159,21 +155,48 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
     }
 }
 
+pub(crate) struct AssistGroup<'a> {
+    ctx: AssistCtx<'a>,
+    group_name: String,
+    assists: Vec<AssistInfo>,
+}
+
+impl<'a> AssistGroup<'a> {
+    pub(crate) fn add_assist(
+        &mut self,
+        id: AssistId,
+        label: impl Into<String>,
+        f: impl FnOnce(&mut ActionBuilder),
+    ) {
+        let label = AssistLabel::new(label.into(), id);
+
+        let mut info = AssistInfo::new(label).with_group(GroupLabel(self.group_name.clone()));
+        if self.ctx.should_compute_edit {
+            let action = {
+                let mut edit = ActionBuilder::default();
+                f(&mut edit);
+                edit.build()
+            };
+            info = info.resolved(action)
+        };
+
+        self.assists.push(info)
+    }
+
+    pub(crate) fn finish(self) -> Option<Assist> {
+        assert!(!self.assists.is_empty());
+        Some(Assist(self.assists))
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct ActionBuilder {
     edit: TextEditBuilder,
     cursor_position: Option<TextUnit>,
     target: Option<TextRange>,
-    label: Option<String>,
 }
 
 impl ActionBuilder {
-    #[allow(dead_code)]
-    /// Adds a custom label to the action, if it needs to be different from the assist label
-    pub(crate) fn label(&mut self, label: impl Into<String>) {
-        self.label = Some(label.into())
-    }
-
     /// Replaces specified `range` of text with a given string.
     pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
         self.edit.replace(range, replace_with.into())
@@ -232,7 +255,6 @@ impl ActionBuilder {
             edit: self.edit.finish(),
             cursor_position: self.cursor_position,
             target: self.target,
-            label: self.label,
         }
     }
 }
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index 5dc1ee233..c0f9bc1fb 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -5,24 +5,24 @@
 
 mod generated;
 
-use ra_db::{fixture::WithFixture, FileRange};
+use ra_db::FileRange;
 use test_utils::{assert_eq_text, extract_range_or_offset};
 
-use crate::test_db::TestDB;
+use crate::resolved_assists;
 
 fn check(assist_id: &str, before: &str, after: &str) {
     let (selection, before) = extract_range_or_offset(before);
-    let (db, file_id) = TestDB::with_single_file(&before);
+    let (db, file_id) = crate::helpers::with_single_file(&before);
     let frange = FileRange { file_id, range: selection.into() };
 
-    let assist = crate::assists(&db, frange)
+    let assist = resolved_assists(&db, frange)
         .into_iter()
         .find(|assist| assist.label.id.0 == assist_id)
         .unwrap_or_else(|| {
             panic!(
                 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                 assist_id,
-                crate::assists(&db, frange)
+                resolved_assists(&db, frange)
                     .into_iter()
                     .map(|assist| assist.label.id.0)
                     .collect::<Vec<_>>()
@@ -30,6 +30,6 @@ fn check(assist_id: &str, before: &str, after: &str) {
             )
         });
 
-    let actual = assist.get_first_action().edit.apply(&before);
+    let actual = assist.action.edit.apply(&before);
     assert_eq_text!(after, &actual);
 }
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 7d84dc8fb..4ab09b167 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 
 use super::check;
 
@@ -161,21 +161,6 @@ impl Trait<u32> for () {
 }
 
 #[test]
-fn doctest_add_import() {
-    check(
-        "add_import",
-        r#####"
-fn process(map: std::collections::<|>HashMap<String, String>) {}
-"#####,
-        r#####"
-use std::collections::HashMap;
-
-fn process(map: HashMap<String, String>) {}
-"#####,
-    )
-}
-
-#[test]
 fn doctest_add_new() {
     check(
         "add_new",
@@ -215,6 +200,27 @@ fn main() {
 }
 
 #[test]
+fn doctest_auto_import() {
+    check(
+        "auto_import",
+        r#####"
+fn main() {
+    let map = HashMap<|>::new();
+}
+pub mod std { pub mod collections { pub struct HashMap { } } }
+"#####,
+        r#####"
+use std::collections::HashMap;
+
+fn main() {
+    let map = HashMap::new();
+}
+pub mod std { pub mod collections { pub struct HashMap { } } }
+"#####,
+    )
+}
+
+#[test]
 fn doctest_change_visibility() {
     check(
         "change_visibility",
@@ -571,6 +577,21 @@ fn handle(action: Action) {
 }
 
 #[test]
+fn doctest_replace_qualified_name_with_use() {
+    check(
+        "replace_qualified_name_with_use",
+        r#####"
+fn process(map: std::collections::<|>HashMap<String, String>) {}
+"#####,
+        r#####"
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_split_import() {
     check(
         "split_import",
diff --git a/crates/ra_assists/src/assists/add_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index f91034967..7fdd816bf 100644
--- a/crates/ra_assists/src/assists/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use crate::{Assist, AssistCtx, AssistId};
-use hir::db::HirDatabase;
+
 use join_to_string::join;
 use ra_syntax::{
     ast::{self, AstNode},
@@ -29,7 +29,7 @@ const DERIVE_TRAIT: &str = "derive";
 //
 // }
 // ```
-pub(crate) fn add_custom_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
     let input = ctx.find_node_at_offset::<ast::AttrInput>()?;
     let attr = input.syntax().parent().and_then(ast::Attr::cast)?;
 
diff --git a/crates/ra_assists/src/assists/add_derive.rs b/crates/ra_assists/src/handlers/add_derive.rs
index 6d9af3905..b0d1a0a80 100644
--- a/crates/ra_assists/src/assists/add_derive.rs
+++ b/crates/ra_assists/src/handlers/add_derive.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner},
     SyntaxKind::{COMMENT, WHITESPACE},
@@ -25,7 +24,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     y: u32,
 // }
 // ```
-pub(crate) fn add_derive(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let node_start = derive_insertion_offset(&nominal)?;
     ctx.add_assist(AssistId("add_derive"), "Add `#[derive]`", |edit| {
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 38a351a54..2cb9d2f48 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -1,7 +1,7 @@
-use hir::{db::HirDatabase, HirDisplay};
+use hir::HirDisplay;
 use ra_syntax::{
-    ast::{self, AstNode, LetStmt, NameOwner},
-    TextRange, T,
+    ast::{self, AstNode, LetStmt, NameOwner, TypeAscriptionOwner},
+    TextRange,
 };
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -21,7 +21,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     let x: i32 = 92;
 // }
 // ```
-pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
     let stmt = ctx.find_node_at_offset::<LetStmt>()?;
     let expr = stmt.initializer()?;
     let pat = stmt.pat()?;
@@ -34,17 +34,21 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
     // The binding must have a name
     let name = pat.name()?;
     let name_range = name.syntax().text_range();
-    // Assist should only be applicable if cursor is between 'let' and '='
     let stmt_range = stmt.syntax().text_range();
     let eq_range = stmt.eq_token()?.text_range();
+    // Assist should only be applicable if cursor is between 'let' and '='
     let let_range = TextRange::from_to(stmt_range.start(), eq_range.start());
     let cursor_in_range = ctx.frange.range.is_subrange(&let_range);
     if !cursor_in_range {
         return None;
     }
     // Assist not applicable if the type has already been specified
-    if stmt.syntax().children_with_tokens().any(|child| child.kind() == T![:]) {
-        return None;
+    // and it has no placeholders
+    let ascribed_ty = stmt.ascribed_type();
+    if let Some(ref ty) = ascribed_ty {
+        if ty.syntax().descendants().find_map(ast::PlaceholderType::cast).is_none() {
+            return None;
+        }
     }
     // Infer type
     let db = ctx.db;
@@ -60,7 +64,11 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
         format!("Insert explicit type '{}'", ty.display(db)),
         |edit| {
             edit.target(pat_range);
-            edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+            if let Some(ascribed_ty) = ascribed_ty {
+                edit.replace(ascribed_ty.syntax().text_range(), format!("{}", ty.display(db)));
+            } else {
+                edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+            }
         },
     )
 }
@@ -86,6 +94,40 @@ mod tests {
     }
 
     #[test]
+    fn add_explicit_type_works_for_underscore() {
+        check_assist(
+            add_explicit_type,
+            "fn f() { let a<|>: _ = 1; }",
+            "fn f() { let a<|>: i32 = 1; }",
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_nested_underscore() {
+        check_assist(
+            add_explicit_type,
+            r#"
+            enum Option<T> {
+                Some(T),
+                None
+            }
+
+            fn f() {
+                let a<|>: Option<_> = Option::Some(1);
+            }"#,
+            r#"
+            enum Option<T> {
+                Some(T),
+                None
+            }
+
+            fn f() {
+                let a<|>: Option<i32> = Option::Some(1);
+            }"#,
+        );
+    }
+
+    #[test]
     fn add_explicit_type_works_for_macro_call() {
         check_assist(
             add_explicit_type,
diff --git a/crates/ra_assists/src/assists/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index 4b326c837..241b085fd 100644
--- a/crates/ra_assists/src/assists/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::db::HirDatabase;
+
 use join_to_string::join;
 use ra_syntax::{
     ast::{self, AstNode, NameOwner, TypeParamsOwner},
@@ -27,7 +27,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //
 // }
 // ```
-pub(crate) fn add_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let name = nominal.name()?;
     ctx.add_assist(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), |edit| {
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 5bb937bde..448697d31 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -43,7 +43,7 @@ enum AddMissingImplMembersMode {
 //
 // }
 // ```
-pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
     add_missing_impl_members_inner(
         ctx,
         AddMissingImplMembersMode::NoDefaultMethods,
@@ -84,7 +84,7 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Opti
 //
 // }
 // ```
-pub(crate) fn add_missing_default_members(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_missing_default_members(ctx: AssistCtx) -> Option<Assist> {
     add_missing_impl_members_inner(
         ctx,
         AddMissingImplMembersMode::DefaultMethodsOnly,
@@ -94,11 +94,12 @@ pub(crate) fn add_missing_default_members(ctx: AssistCtx<impl HirDatabase>) -> O
 }
 
 fn add_missing_impl_members_inner(
-    ctx: AssistCtx<impl HirDatabase>,
+    ctx: AssistCtx,
     mode: AddMissingImplMembersMode,
     assist_id: &'static str,
     label: &'static str,
 ) -> Option<Assist> {
+    let _p = ra_prof::profile("add_missing_impl_members_inner");
     let impl_node = ctx.find_node_at_offset::<ast::ImplBlock>()?;
     let impl_item_list = impl_node.item_list()?;
 
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index 8db63f762..2701eddb8 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::{db::HirDatabase, InFile};
+use hir::{Adt, InFile};
 use join_to_string::join;
 use ra_syntax::{
     ast::{
@@ -31,7 +31,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 //
 // ```
-pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
     let strukt = ctx.find_node_at_offset::<ast::StructDef>()?;
 
     // We want to only apply this to non-union structs with named fields
@@ -128,26 +128,29 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
 //
 // FIXME: change the new fn checking to a more semantic approach when that's more
 // viable (e.g. we process proc macros, etc)
-fn find_struct_impl(
-    ctx: &AssistCtx<impl HirDatabase>,
-    strukt: &ast::StructDef,
-) -> Option<Option<ast::ImplBlock>> {
+fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<ast::ImplBlock>> {
     let db = ctx.db;
     let module = strukt.syntax().ancestors().find(|node| {
         ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
     })?;
     let mut sb = ctx.source_binder();
 
-    let struct_ty = {
+    let struct_def = {
         let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        sb.to_def(src)?.ty(db)
+        sb.to_def(src)?
     };
 
     let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
         let src = InFile { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
         let blk = sb.to_def(src)?;
 
-        let same_ty = blk.target_ty(db) == struct_ty;
+        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
+        // (we currently use the wrong type parameter)
+        // also we wouldn't want to use e.g. `impl S<u32>`
+        let same_ty = match blk.target_ty(db).as_adt() {
+            Some(def) => def == Adt::Struct(struct_def),
+            None => false,
+        };
         let not_trait_impl = blk.target_trait(db).is_none();
 
         if !(same_ty && not_trait_impl) {
diff --git a/crates/ra_assists/src/assists/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 666dce4e6..239807e24 100644
--- a/crates/ra_assists/src/assists/apply_demorgan.rs
+++ b/crates/ra_assists/src/handlers/apply_demorgan.rs
@@ -1,8 +1,6 @@
-use super::invert_if::invert_boolean_expression;
-use hir::db::HirDatabase;
 use ra_syntax::ast::{self, AstNode};
 
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
 
 // Assist: apply_demorgan
 //
@@ -23,7 +21,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     if !(x == 4 && y) {}
 // }
 // ```
-pub(crate) fn apply_demorgan(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn apply_demorgan(ctx: AssistCtx) -> Option<Assist> {
     let expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
     let op = expr.op_kind()?;
     let op_range = expr.op_token()?.text_range();
@@ -32,12 +30,14 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
     if !cursor_in_range {
         return None;
     }
+
     let lhs = expr.lhs()?;
     let lhs_range = lhs.syntax().text_range();
+    let not_lhs = invert_boolean_expression(lhs);
+
     let rhs = expr.rhs()?;
     let rhs_range = rhs.syntax().text_range();
-    let not_lhs = invert_boolean_expression(&lhs)?;
-    let not_rhs = invert_boolean_expression(&rhs)?;
+    let not_rhs = invert_boolean_expression(rhs);
 
     ctx.add_assist(AssistId("apply_demorgan"), "Apply De Morgan's law", |edit| {
         edit.target(op_range);
@@ -78,12 +78,12 @@ mod tests {
     }
 
     #[test]
-    fn demorgan_doesnt_apply_with_cursor_not_on_op() {
-        check_assist_not_applicable(apply_demorgan, "fn f() { <|> !x || !x }")
+    fn demorgan_general_case() {
+        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x &&<|> !x) }")
     }
 
     #[test]
-    fn demorgan_doesnt_apply_when_operands_arent_negated_already() {
-        check_assist_not_applicable(apply_demorgan, "fn f() { x ||<|> x }")
+    fn demorgan_doesnt_apply_with_cursor_not_on_op() {
+        check_assist_not_applicable(apply_demorgan, "fn f() { <|> !x || !x }")
     }
 }
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
new file mode 100644
index 000000000..1fb701da5
--- /dev/null
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -0,0 +1,293 @@
+use ra_ide_db::imports_locator::ImportsLocator;
+use ra_syntax::ast::{self, AstNode};
+
+use crate::{
+    assist_ctx::{Assist, AssistCtx},
+    insert_use_statement, AssistId,
+};
+use std::collections::BTreeSet;
+
+// Assist: auto_import
+//
+// If the name is unresolved, provides all possible imports for it.
+//
+// ```
+// fn main() {
+//     let map = HashMap<|>::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+// ->
+// ```
+// use std::collections::HashMap;
+//
+// fn main() {
+//     let map = HashMap::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
+    let path_under_caret: ast::Path = ctx.find_node_at_offset()?;
+    if path_under_caret.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
+        return None;
+    }
+
+    let module = path_under_caret.syntax().ancestors().find_map(ast::Module::cast);
+    let position = match module.and_then(|it| it.item_list()) {
+        Some(item_list) => item_list.syntax().clone(),
+        None => {
+            let current_file =
+                path_under_caret.syntax().ancestors().find_map(ast::SourceFile::cast)?;
+            current_file.syntax().clone()
+        }
+    };
+    let source_analyzer = ctx.source_analyzer(&position, None);
+    let module_with_name_to_import = source_analyzer.module()?;
+
+    let name_ref_to_import =
+        path_under_caret.syntax().descendants().find_map(ast::NameRef::cast)?;
+    if source_analyzer
+        .resolve_path(ctx.db, &name_ref_to_import.syntax().ancestors().find_map(ast::Path::cast)?)
+        .is_some()
+    {
+        return None;
+    }
+
+    let name_to_import = name_ref_to_import.syntax().to_string();
+    let proposed_imports = ImportsLocator::new(ctx.db)
+        .find_imports(&name_to_import)
+        .into_iter()
+        .filter_map(|module_def| module_with_name_to_import.find_use_path(ctx.db, module_def))
+        .filter(|use_path| !use_path.segments.is_empty())
+        .take(20)
+        .collect::<BTreeSet<_>>();
+
+    if proposed_imports.is_empty() {
+        return None;
+    }
+
+    let mut group = ctx.add_assist_group(format!("Import {}", name_to_import));
+    for import in proposed_imports {
+        group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
+            edit.target(path_under_caret.syntax().text_range());
+            insert_use_statement(
+                &position,
+                path_under_caret.syntax(),
+                &import,
+                edit.text_edit_builder(),
+            );
+        });
+    }
+    group.finish()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    use super::*;
+
+    #[test]
+    fn applicable_when_found_an_import() {
+        check_assist(
+            auto_import,
+            r"
+            <|>PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            <|>use PubMod::PubStruct;
+
+            PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn auto_imports_are_merged() {
+        check_assist(
+            auto_import,
+            r"
+            use PubMod::PubStruct1;
+
+            struct Test {
+                test: Pub<|>Struct2<u8>,
+            }
+
+            pub mod PubMod {
+                pub struct PubStruct1;
+                pub struct PubStruct2<T> {
+                    _t: T,
+                }
+            }
+            ",
+            r"
+            use PubMod::{PubStruct2, PubStruct1};
+
+            struct Test {
+                test: Pub<|>Struct2<u8>,
+            }
+
+            pub mod PubMod {
+                pub struct PubStruct1;
+                pub struct PubStruct2<T> {
+                    _t: T,
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_multiple_imports() {
+        check_assist(
+            auto_import,
+            r"
+            PubSt<|>ruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod1::PubStruct;
+
+            PubSt<|>ruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_already_imported_types() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_types_with_private_paths() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            PrivateStruct<|>
+
+            pub mod PubMod {
+                struct PrivateStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_when_no_imports_found() {
+        check_assist_not_applicable(
+            auto_import,
+            "
+            PubStruct<|>",
+        );
+    }
+
+    #[test]
+    fn not_applicable_in_import_statements() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            use PubStruct<|>;
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }",
+        );
+    }
+
+    #[test]
+    fn function_import() {
+        check_assist(
+            auto_import,
+            r"
+            test_function<|>
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+            r"
+            use PubMod::test_function;
+
+            test_function<|>
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn auto_import_target() {
+        check_assist_target(
+            auto_import,
+            r"
+            struct AssistInfo {
+                group_label: Option<<|>GroupLabel>,
+            }
+
+            mod m { pub struct GroupLabel; }
+            ",
+            "GroupLabel",
+        )
+    }
+
+    #[test]
+    fn not_applicable_when_path_start_is_imported() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            pub mod mod1 {
+                pub mod mod2 {
+                    pub mod mod3 {
+                        pub struct TestStruct;
+                    }
+                }
+            }
+
+            use mod1::mod2;
+            fn main() {
+                mod2::mod3::TestStruct<|>
+            }
+            ",
+        );
+    }
+}
diff --git a/crates/ra_assists/src/assists/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index fd766bb46..f325b6f92 100644
--- a/crates/ra_assists/src/assists/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
@@ -22,14 +21,14 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // pub(crate) fn frobnicate() {}
 // ```
-pub(crate) fn change_visibility(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn change_visibility(ctx: AssistCtx) -> Option<Assist> {
     if let Some(vis) = ctx.find_node_at_offset::<ast::Visibility>() {
         return change_vis(ctx, vis);
     }
     add_vis(ctx)
 }
 
-fn add_vis(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+fn add_vis(ctx: AssistCtx) -> Option<Assist> {
     let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
         T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
         _ => false,
@@ -75,7 +74,7 @@ fn vis_offset(node: &SyntaxNode) -> TextUnit {
         .unwrap_or_else(|| node.text_range().start())
 }
 
-fn change_vis(ctx: AssistCtx<impl HirDatabase>, vis: ast::Visibility) -> Option<Assist> {
+fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
     if vis.syntax().text() == "pub" {
         return ctx.add_assist(
             AssistId("change_visibility"),
diff --git a/crates/ra_assists/src/assists/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 487ee9eef..22f88884f 100644
--- a/crates/ra_assists/src/assists/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -1,6 +1,5 @@
 use std::{iter::once, ops::RangeInclusive};
 
-use hir::db::HirDatabase;
 use ra_syntax::{
     algo::replace_children,
     ast::{self, edit::IndentLevel, make, Block, Pat::TupleStructPat},
@@ -11,6 +10,7 @@ use ra_syntax::{
 
 use crate::{
     assist_ctx::{Assist, AssistCtx},
+    utils::invert_boolean_expression,
     AssistId,
 };
 
@@ -36,7 +36,7 @@ use crate::{
 //     bar();
 // }
 // ```
-pub(crate) fn convert_to_guarded_return(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
     let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
     if if_expr.else_branch().is_some() {
         return None;
@@ -100,9 +100,13 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx<impl HirDatabase>) -> Opt
         let new_block = match if_let_pat {
             None => {
                 // If.
-                let early_expression = &(early_expression.syntax().to_string() + ";");
-                let new_expr = if_indent_level
-                    .increase_indent(make::if_expression(&cond_expr, early_expression));
+                let new_expr = {
+                    let then_branch =
+                        make::block_expr(once(make::expr_stmt(early_expression).into()), None);
+                    let cond = invert_boolean_expression(cond_expr);
+                    let e = make::expr_if(cond, then_branch);
+                    if_indent_level.increase_indent(e)
+                };
                 replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
             }
             Some((path, bound_ident)) => {
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 01758d23a..0908fc246 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -31,7 +31,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
     let match_expr = ctx.find_node_at_offset::<ast::MatchExpr>()?;
     let match_arm_list = match_expr.match_arm_list()?;
 
diff --git a/crates/ra_assists/src/assists/flip_binexpr.rs b/crates/ra_assists/src/handlers/flip_binexpr.rs
index 2074087cd..bfcc09e90 100644
--- a/crates/ra_assists/src/assists/flip_binexpr.rs
+++ b/crates/ra_assists/src/handlers/flip_binexpr.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::ast::{AstNode, BinExpr, BinOp};
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -18,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     let _ = 2 + 90;
 // }
 // ```
-pub(crate) fn flip_binexpr(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn flip_binexpr(ctx: AssistCtx) -> Option<Assist> {
     let expr = ctx.find_node_at_offset::<BinExpr>()?;
     let lhs = expr.lhs()?.syntax().clone();
     let rhs = expr.rhs()?.syntax().clone();
diff --git a/crates/ra_assists/src/assists/flip_comma.rs b/crates/ra_assists/src/handlers/flip_comma.rs
index dd0c405ed..1dacf29f8 100644
--- a/crates/ra_assists/src/assists/flip_comma.rs
+++ b/crates/ra_assists/src/handlers/flip_comma.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{algo::non_trivia_sibling, Direction, T};
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -18,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     ((3, 4), (1, 2));
 // }
 // ```
-pub(crate) fn flip_comma(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
     let comma = ctx.find_token_at_offset(T![,])?;
     let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?;
     let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?;
diff --git a/crates/ra_assists/src/assists/flip_trait_bound.rs b/crates/ra_assists/src/handlers/flip_trait_bound.rs
index 50b3fa492..f56769624 100644
--- a/crates/ra_assists/src/assists/flip_trait_bound.rs
+++ b/crates/ra_assists/src/handlers/flip_trait_bound.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     algo::non_trivia_sibling,
     ast::{self, AstNode},
@@ -18,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // fn foo<T: Copy + Clone>() { }
 // ```
-pub(crate) fn flip_trait_bound(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn flip_trait_bound(ctx: AssistCtx) -> Option<Assist> {
     // We want to replicate the behavior of `flip_binexpr` by only suggesting
     // the assist when the cursor is on a `+`
     let plus = ctx.find_token_at_offset(T![+])?;
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index d0c5c3b8c..91b588243 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode, AstToken},
     TextRange,
@@ -23,7 +22,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     (1 + 2) * 4;
 // }
 // ```
-pub(crate) fn inline_local_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
     let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
     let bind_pat = match let_stmt.pat()? {
         ast::Pat::BindPat(pat) => pat,
@@ -47,6 +46,9 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<
     };
     let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
     let refs = analyzer.find_all_refs(&bind_pat);
+    if refs.is_empty() {
+        return None;
+    };
 
     let mut wrap_in_parens = vec![true; refs.len()];
 
@@ -645,4 +647,16 @@ fn foo() {
 }",
         );
     }
+
+    #[test]
+    fn test_not_applicable_if_variable_unused() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            "
+fn foo() {
+    let <|>a = 0;
+}
+            ",
+        )
+    }
 }
diff --git a/crates/ra_assists/src/assists/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index 19e211e0f..7312ce687 100644
--- a/crates/ra_assists/src/assists/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -1,5 +1,4 @@
 use format_buf::format;
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode},
     SyntaxKind::{
@@ -28,7 +27,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     var_name * 4;
 // }
 // ```
-pub(crate) fn introduce_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
     if ctx.frange.range.is_empty() {
         return None;
     }
diff --git a/crates/ra_assists/src/assists/invert_if.rs b/crates/ra_assists/src/handlers/invert_if.rs
index 16352c040..a594e7e0c 100644
--- a/crates/ra_assists/src/assists/invert_if.rs
+++ b/crates/ra_assists/src/handlers/invert_if.rs
@@ -1,8 +1,7 @@
-use hir::db::HirDatabase;
 use ra_syntax::ast::{self, AstNode};
 use ra_syntax::T;
 
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
 
 // Assist: invert_if
 //
@@ -23,7 +22,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 // ```
 
-pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn invert_if(ctx: AssistCtx) -> Option<Assist> {
     let if_keyword = ctx.find_token_at_offset(T![if])?;
     let expr = ast::IfExpr::cast(if_keyword.parent())?;
     let if_range = if_keyword.text_range();
@@ -36,8 +35,8 @@ pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let then_node = expr.then_branch()?.syntax().clone();
 
     if let ast::ElseBranch::Block(else_block) = expr.else_branch()? {
-        let flip_cond = invert_boolean_expression(&cond)?;
         let cond_range = cond.syntax().text_range();
+        let flip_cond = invert_boolean_expression(cond);
         let else_node = else_block.syntax();
         let else_range = else_node.text_range();
         let then_range = then_node.text_range();
@@ -52,20 +51,6 @@ pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     None
 }
 
-pub(crate) fn invert_boolean_expression(expr: &ast::Expr) -> Option<ast::Expr> {
-    match expr {
-        ast::Expr::BinExpr(bin) => match bin.op_kind()? {
-            ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
-            _ => None,
-        },
-        ast::Expr::PrefixExpr(pe) => match pe.op_kind()? {
-            ast::PrefixOp::Not => pe.expr(),
-            _ => None,
-        },
-        _ => None,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -91,12 +76,16 @@ mod tests {
     }
 
     #[test]
-    fn invert_if_doesnt_apply_with_cursor_not_on_if() {
-        check_assist_not_applicable(invert_if, "fn f() { if !<|>cond { 3 * 2 } else { 1 } }")
+    fn invert_if_general_case() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f cond { 3 * 2 } else { 1 } }",
+            "fn f() { i<|>f !cond { 1 } else { 3 * 2 } }",
+        )
     }
 
     #[test]
-    fn invert_if_doesnt_apply_without_negated() {
-        check_assist_not_applicable(invert_if, "fn f() { i<|>f cond { 3 * 2 } else { 1 } }")
+    fn invert_if_doesnt_apply_with_cursor_not_on_if() {
+        check_assist_not_applicable(invert_if, "fn f() { if !<|>cond { 3 * 2 } else { 1 } }")
     }
 }
diff --git a/crates/ra_assists/src/assists/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index aca391155..670614dd8 100644
--- a/crates/ra_assists/src/assists/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -1,6 +1,11 @@
-use crate::{Assist, AssistCtx, AssistId, TextRange, TextUnit};
-use hir::db::HirDatabase;
-use ra_syntax::ast::{AstNode, MatchArm};
+use std::iter::successors;
+
+use ra_syntax::{
+    ast::{self, AstNode},
+    Direction, TextUnit,
+};
+
+use crate::{Assist, AssistCtx, AssistId, TextRange};
 
 // Assist: merge_match_arms
 //
@@ -26,63 +31,81 @@ use ra_syntax::ast::{AstNode, MatchArm};
 //     }
 // }
 // ```
-pub(crate) fn merge_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let current_arm = ctx.find_node_at_offset::<MatchArm>()?;
-
-    // We check if the following match arm matches this one. We could, but don't,
-    // compare to the previous match arm as well.
-    let next = current_arm.syntax().next_sibling();
-    let next_arm = MatchArm::cast(next?)?;
-
+pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
+    let current_arm = ctx.find_node_at_offset::<ast::MatchArm>()?;
     // Don't try to handle arms with guards for now - can add support for this later
-    if current_arm.guard().is_some() || next_arm.guard().is_some() {
+    if current_arm.guard().is_some() {
         return None;
     }
-
     let current_expr = current_arm.expr()?;
-    let next_expr = next_arm.expr()?;
+    let current_text_range = current_arm.syntax().text_range();
 
-    // Check for match arm equality by comparing lengths and then string contents
-    if current_expr.syntax().text_range().len() != next_expr.syntax().text_range().len() {
-        return None;
+    enum CursorPos {
+        InExpr(TextUnit),
+        InPat(TextUnit),
     }
-    if current_expr.syntax().text() != next_expr.syntax().text() {
+    let cursor_pos = ctx.frange.range.start();
+    let cursor_pos = if current_expr.syntax().text_range().contains(cursor_pos) {
+        CursorPos::InExpr(current_text_range.end() - cursor_pos)
+    } else {
+        CursorPos::InPat(cursor_pos)
+    };
+
+    // We check if the following match arms match this one. We could, but don't,
+    // compare to the previous match arm as well.
+    let arms_to_merge = successors(Some(current_arm), next_arm)
+        .take_while(|arm| {
+            if arm.guard().is_some() {
+                return false;
+            }
+            match arm.expr() {
+                Some(expr) => expr.syntax().text() == current_expr.syntax().text(),
+                None => false,
+            }
+        })
+        .collect::<Vec<_>>();
+
+    if arms_to_merge.len() <= 1 {
         return None;
     }
 
-    let cursor_to_end = current_arm.syntax().text_range().end() - ctx.frange.range.start();
-
     ctx.add_assist(AssistId("merge_match_arms"), "Merge match arms", |edit| {
-        fn contains_placeholder(a: &MatchArm) -> bool {
-            a.pats().any(|x| match x {
-                ra_syntax::ast::Pat::PlaceholderPat(..) => true,
-                _ => false,
-            })
-        }
-
-        let pats = if contains_placeholder(&current_arm) || contains_placeholder(&next_arm) {
+        let pats = if arms_to_merge.iter().any(contains_placeholder) {
             "_".into()
         } else {
-            let ps: Vec<String> = current_arm
-                .pats()
+            arms_to_merge
+                .iter()
+                .flat_map(ast::MatchArm::pats)
                 .map(|x| x.syntax().to_string())
-                .chain(next_arm.pats().map(|x| x.syntax().to_string()))
-                .collect();
-            ps.join(" | ")
+                .collect::<Vec<String>>()
+                .join(" | ")
         };
 
         let arm = format!("{} => {}", pats, current_expr.syntax().text());
-        let offset = TextUnit::from_usize(arm.len()) - cursor_to_end;
 
-        let start = current_arm.syntax().text_range().start();
-        let end = next_arm.syntax().text_range().end();
+        let start = arms_to_merge.first().unwrap().syntax().text_range().start();
+        let end = arms_to_merge.last().unwrap().syntax().text_range().end();
 
-        edit.target(current_arm.syntax().text_range());
+        edit.target(current_text_range);
+        edit.set_cursor(match cursor_pos {
+            CursorPos::InExpr(back_offset) => start + TextUnit::from_usize(arm.len()) - back_offset,
+            CursorPos::InPat(offset) => offset,
+        });
         edit.replace(TextRange::from_to(start, end), arm);
-        edit.set_cursor(start + offset);
     })
 }
 
+fn contains_placeholder(a: &ast::MatchArm) -> bool {
+    a.pats().any(|x| match x {
+        ra_syntax::ast::Pat::PlaceholderPat(..) => true,
+        _ => false,
+    })
+}
+
+fn next_arm(arm: &ast::MatchArm) -> Option<ast::MatchArm> {
+    arm.syntax().siblings(Direction::Next).skip(1).find_map(ast::MatchArm::cast)
+}
+
 #[cfg(test)]
 mod tests {
     use super::merge_match_arms;
@@ -185,6 +208,37 @@ mod tests {
     }
 
     #[test]
+    fn merges_all_subsequent_arms() {
+        check_assist(
+            merge_match_arms,
+            r#"
+            enum X { A, B, C, D, E }
+
+            fn main() {
+                match X::A {
+                    X::A<|> => 92,
+                    X::B => 92,
+                    X::C => 92,
+                    X::D => 62,
+                    _ => panic!(),
+                }
+            }
+            "#,
+            r#"
+            enum X { A, B, C, D, E }
+
+            fn main() {
+                match X::A {
+                    X::A<|> | X::B | X::C => 92,
+                    X::D => 62,
+                    _ => panic!(),
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
     fn merge_match_arms_rejects_guards() {
         check_assist_not_applicable(
             merge_match_arms,
diff --git a/crates/ra_assists/src/assists/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index 355adddc3..90793b5fc 100644
--- a/crates/ra_assists/src/assists/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, edit, make, AstNode, NameOwner, TypeBoundsOwner},
     SyntaxElement,
@@ -22,7 +21,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     f(x)
 // }
 // ```
-pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
     let type_param_list = ctx.find_node_at_offset::<ast::TypeParamList>()?;
 
     let mut type_params = type_param_list.type_params();
diff --git a/crates/ra_assists/src/assists/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index 41a31e677..2b91ce7c4 100644
--- a/crates/ra_assists/src/assists/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast,
     ast::{AstNode, AstToken, IfExpr, MatchArm},
@@ -32,7 +31,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
     let match_arm = ctx.find_node_at_offset::<MatchArm>()?;
     let guard = match_arm.guard()?;
     let space_before_guard = guard.syntax().prev_sibling_or_token();
@@ -89,7 +88,7 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx<impl HirDatabase>) -> Option
 //     }
 // }
 // ```
-pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
     let match_arm: MatchArm = ctx.find_node_at_offset::<MatchArm>()?;
     let last_match_pat = match_arm.pats().last()?;
 
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index e79c51673..2c0a1e126 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast, AstToken,
     SyntaxKind::{RAW_STRING, STRING},
@@ -22,7 +21,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     r#"Hello, World!"#;
 // }
 // ```
-pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn make_raw_string(ctx: AssistCtx) -> Option<Assist> {
     let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
     let value = token.value()?;
     ctx.add_assist(AssistId("make_raw_string"), "Rewrite as raw string", |edit| {
@@ -51,7 +50,7 @@ pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 //     "Hello, \"World!\"";
 // }
 // ```
-pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn make_usual_string(ctx: AssistCtx) -> Option<Assist> {
     let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
     let value = token.value()?;
     ctx.add_assist(AssistId("make_usual_string"), "Rewrite as regular string", |edit| {
@@ -77,7 +76,7 @@ pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 //     r##"Hello, World!"##;
 // }
 // ```
-pub(crate) fn add_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn add_hash(ctx: AssistCtx) -> Option<Assist> {
     let token = ctx.find_token_at_offset(RAW_STRING)?;
     ctx.add_assist(AssistId("add_hash"), "Add # to raw string", |edit| {
         edit.target(token.text_range());
@@ -101,7 +100,7 @@ pub(crate) fn add_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
 //     r"Hello, World!";
 // }
 // ```
-pub(crate) fn remove_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn remove_hash(ctx: AssistCtx) -> Option<Assist> {
     let token = ctx.find_token_at_offset(RAW_STRING)?;
     let text = token.text().as_str();
     if text.starts_with("r\"") {
diff --git a/crates/ra_assists/src/assists/remove_dbg.rs b/crates/ra_assists/src/handlers/remove_dbg.rs
index cf211ab84..5085649b4 100644
--- a/crates/ra_assists/src/assists/remove_dbg.rs
+++ b/crates/ra_assists/src/handlers/remove_dbg.rs
@@ -1,4 +1,3 @@
-use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode},
     TextUnit, T,
@@ -21,7 +20,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     92;
 // }
 // ```
-pub(crate) fn remove_dbg(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
     let macro_call = ctx.find_node_at_offset::<ast::MacroCall>()?;
 
     if !is_valid_macrocall(&macro_call, "dbg")? {
diff --git a/crates/ra_assists/src/assists/replace_if_let_with_match.rs b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
index c9b62e5ff..e6cd50bc1 100644
--- a/crates/ra_assists/src/assists/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
@@ -1,9 +1,11 @@
-use format_buf::format;
-use hir::db::HirDatabase;
-use ra_fmt::extract_trivial_expression;
-use ra_syntax::{ast, AstNode};
+use ra_fmt::unwrap_trivial_block;
+use ra_syntax::{
+    ast::{self, make},
+    AstNode,
+};
 
 use crate::{Assist, AssistCtx, AssistId};
+use ast::edit::IndentLevel;
 
 // Assist: replace_if_let_with_match
 //
@@ -31,7 +33,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-pub(crate) fn replace_if_let_with_match(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
     let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
     let cond = if_expr.condition()?;
     let pat = cond.pat()?;
@@ -43,32 +45,24 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx<impl HirDatabase>) -> Opt
     };
 
     ctx.add_assist(AssistId("replace_if_let_with_match"), "Replace with match", |edit| {
-        let match_expr = build_match_expr(expr, pat, then_block, else_block);
-        edit.target(if_expr.syntax().text_range());
-        edit.replace_node_and_indent(if_expr.syntax(), match_expr);
-        edit.set_cursor(if_expr.syntax().text_range().start())
-    })
-}
+        let match_expr = {
+            let then_arm = {
+                let then_expr = unwrap_trivial_block(then_block);
+                make::match_arm(vec![pat], then_expr)
+            };
+            let else_arm = {
+                let else_expr = unwrap_trivial_block(else_block);
+                make::match_arm(vec![make::placeholder_pat().into()], else_expr)
+            };
+            make::expr_match(expr, make::match_arm_list(vec![then_arm, else_arm]))
+        };
 
-fn build_match_expr(
-    expr: ast::Expr,
-    pat1: ast::Pat,
-    arm1: ast::BlockExpr,
-    arm2: ast::BlockExpr,
-) -> String {
-    let mut buf = String::new();
-    format!(buf, "match {} {{\n", expr.syntax().text());
-    format!(buf, "    {} => {}\n", pat1.syntax().text(), format_arm(&arm1));
-    format!(buf, "    _ => {}\n", format_arm(&arm2));
-    buf.push_str("}");
-    buf
-}
+        let match_expr = IndentLevel::from_node(if_expr.syntax()).increase_indent(match_expr);
 
-fn format_arm(block: &ast::BlockExpr) -> String {
-    match extract_trivial_expression(block) {
-        Some(e) if !e.syntax().text().contains_char('\n') => format!("{},", e.syntax().text()),
-        _ => block.syntax().text().to_string(),
-    }
+        edit.target(if_expr.syntax().text_range());
+        edit.set_cursor(if_expr.syntax().text_range().start());
+        edit.replace_ast::<ast::Expr>(if_expr.into(), match_expr.into());
+    })
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/assists/add_import.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index bf6cfe865..b70c88ec2 100644
--- a/crates/ra_assists/src/assists/add_import.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,4 +1,4 @@
-use hir::{self, db::HirDatabase};
+use hir::{self, ModPath};
 use ra_syntax::{
     ast::{self, NameOwner},
     AstNode, Direction, SmolStr,
@@ -12,18 +12,18 @@ use crate::{
     AssistId,
 };
 
-/// This function produces sequence of text edits into edit
-/// to import the target path in the most appropriate scope given
-/// the cursor position
-pub fn auto_import_text_edit(
+/// Creates and inserts a use statement for the given path to import.
+/// The use statement is inserted in the scope most appropriate to the
+/// the cursor position given, additionally merged with the existing use imports.
+pub fn insert_use_statement(
     // Ideally the position of the cursor, used to
     position: &SyntaxNode,
     // The statement to use as anchor (last resort)
     anchor: &SyntaxNode,
-    // The path to import as a sequence of strings
-    target: &[SmolStr],
+    path_to_import: &ModPath,
     edit: &mut TextEditBuilder,
 ) {
+    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
     let container = position.ancestors().find_map(|n| {
         if let Some(module) = ast::Module::cast(n.clone()) {
             return module.item_list().map(|it| it.syntax().clone());
@@ -32,14 +32,14 @@ pub fn auto_import_text_edit(
     });
 
     if let Some(container) = container {
-        let action = best_action_for_target(container, anchor.clone(), target);
-        make_assist(&action, target, edit);
+        let action = best_action_for_target(container, anchor.clone(), &target);
+        make_assist(&action, &target, edit);
     }
 }
 
-// Assist: add_import
+// Assist: replace_qualified_name_with_use
 //
-// Adds a use statement for a given fully-qualified path.
+// Adds a use statement for a given fully-qualified name.
 //
 // ```
 // fn process(map: std::collections::<|>HashMap<String, String>) {}
@@ -50,7 +50,7 @@ pub fn auto_import_text_edit(
 //
 // fn process(map: HashMap<String, String>) {}
 // ```
-pub(crate) fn add_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist> {
     let path: ast::Path = ctx.find_node_at_offset()?;
     // We don't want to mess with use statements
     if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
@@ -72,9 +72,13 @@ pub(crate) fn add_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         }
     };
 
-    ctx.add_assist(AssistId("add_import"), format!("Import {}", fmt_segments(&segments)), |edit| {
-        apply_auto_import(&position, &path, &segments, edit.text_edit_builder());
-    })
+    ctx.add_assist(
+        AssistId("replace_qualified_name_with_use"),
+        "Replace qualified path with use",
+        |edit| {
+            replace_with_use(&position, &path, &segments, edit.text_edit_builder());
+        },
+    )
 }
 
 fn collect_path_segments_raw(
@@ -107,12 +111,6 @@ fn collect_path_segments_raw(
     Some(segments.len() - oldlen)
 }
 
-fn fmt_segments(segments: &[SmolStr]) -> String {
-    let mut buf = String::new();
-    fmt_segments_raw(segments, &mut buf);
-    buf
-}
-
 fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
     let mut iter = segments.iter();
     if let Some(s) = iter.next() {
@@ -558,7 +556,7 @@ fn make_assist_add_nested_import(
     }
 }
 
-fn apply_auto_import(
+fn replace_with_use(
     container: &SyntaxNode,
     path: &ast::Path,
     target: &[SmolStr],
@@ -567,7 +565,7 @@ fn apply_auto_import(
     let action = best_action_for_target(container.clone(), path.syntax().clone(), target);
     make_assist(&action, target, edit);
     if let Some(last) = path.segment() {
-        // Here we are assuming the assist will provide a  correct use statement
+        // Here we are assuming the assist will provide a correct use statement
         // so we can delete the path qualifier
         edit.delete(TextRange::from_to(
             path.syntax().text_range().start(),
@@ -603,9 +601,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_auto_import_add_use_no_anchor() {
+    fn test_replace_add_use_no_anchor() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt::Debug<|>
     ",
@@ -617,9 +615,9 @@ Debug<|>
         );
     }
     #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_below() {
+    fn test_replace_add_use_no_anchor_with_item_below() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt::Debug<|>
 
@@ -638,9 +636,9 @@ fn main() {
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_above() {
+    fn test_replace_add_use_no_anchor_with_item_above() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 fn main() {
 }
@@ -659,9 +657,9 @@ Debug<|>
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_2seg() {
+    fn test_replace_add_use_no_anchor_2seg() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt<|>::Debug
     ",
@@ -674,9 +672,9 @@ fmt<|>::Debug
     }
 
     #[test]
-    fn test_auto_import_add_use() {
+    fn test_replace_add_use() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use stdx;
 
@@ -694,9 +692,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_file_use_other_anchor() {
+    fn test_replace_file_use_other_anchor() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 impl std::fmt::Debug<|> for Foo {
 }
@@ -711,9 +709,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_use_other_anchor_indent() {
+    fn test_replace_add_use_other_anchor_indent() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
     impl std::fmt::Debug<|> for Foo {
     }
@@ -728,9 +726,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_different() {
+    fn test_replace_split_different() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt;
 
@@ -747,9 +745,9 @@ impl io<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_self_for_use() {
+    fn test_replace_split_self_for_use() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt;
 
@@ -766,9 +764,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_self_for_target() {
+    fn test_replace_split_self_for_target() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::Debug;
 
@@ -785,9 +783,9 @@ impl fmt<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_self_nested() {
+    fn test_replace_add_to_nested_self_nested() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{Display}};
 
@@ -804,9 +802,9 @@ impl nested<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_self_already_included() {
+    fn test_replace_add_to_nested_self_already_included() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{self, Display}};
 
@@ -823,9 +821,9 @@ impl nested<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_nested() {
+    fn test_replace_add_to_nested_nested() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{Display}};
 
@@ -842,9 +840,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_common_target_longer() {
+    fn test_replace_split_common_target_longer() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::Debug;
 
@@ -861,9 +859,9 @@ impl Display<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_common_use_longer() {
+    fn test_replace_split_common_use_longer() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::nested::Debug;
 
@@ -880,9 +878,9 @@ impl Display<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_use_nested_import() {
+    fn test_replace_use_nested_import() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use crate::{
     ty::{Substs, Ty},
@@ -903,9 +901,9 @@ fn foo() { lower<|>::trait_env() }
     }
 
     #[test]
-    fn test_auto_import_alias() {
+    fn test_replace_alias() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt as foo;
 
@@ -922,9 +920,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_not_applicable_one_segment() {
+    fn test_replace_not_applicable_one_segment() {
         check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
             "
 impl foo<|> for Foo {
 }
@@ -933,9 +931,9 @@ impl foo<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_not_applicable_in_use() {
+    fn test_replace_not_applicable_in_use() {
         check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt<|>;
 ",
@@ -943,9 +941,9 @@ use std::fmt<|>;
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_in_mod_mod() {
+    fn test_replace_add_use_no_anchor_in_mod_mod() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 mod foo {
     mod bar {
diff --git a/crates/ra_assists/src/assists/split_import.rs b/crates/ra_assists/src/handlers/split_import.rs
index 6038c4858..2c3f07a79 100644
--- a/crates/ra_assists/src/assists/split_import.rs
+++ b/crates/ra_assists/src/handlers/split_import.rs
@@ -1,6 +1,5 @@
 use std::iter::successors;
 
-use hir::db::HirDatabase;
 use ra_syntax::{ast, AstNode, TextUnit, T};
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -16,7 +15,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // use std::{collections::HashMap};
 // ```
-pub(crate) fn split_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
     let colon_colon = ctx.find_token_at_offset(T![::])?;
     let path = ast::Path::cast(colon_colon.parent())?;
     let top_path = successors(Some(path), |it| it.parent_path()).last()?;
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 3337805a5..828a8e9e8 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -9,18 +9,16 @@ mod assist_ctx;
 mod marks;
 #[cfg(test)]
 mod doc_tests;
-#[cfg(test)]
-mod test_db;
+mod utils;
 pub mod ast_transform;
 
-use either::Either;
-use hir::db::HirDatabase;
 use ra_db::FileRange;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 
-pub(crate) use crate::assist_ctx::{Assist, AssistCtx};
-pub use crate::assists::add_import::auto_import_text_edit;
+pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
+pub use crate::handlers::replace_qualified_name_with_use::insert_use_statement;
 
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
@@ -34,81 +32,64 @@ pub struct AssistLabel {
     pub id: AssistId,
 }
 
+#[derive(Clone, Debug)]
+pub struct GroupLabel(pub String);
+
+impl AssistLabel {
+    pub(crate) fn new(label: String, id: AssistId) -> AssistLabel {
+        // FIXME: make fields private, so that this invariant can't be broken
+        assert!(label.chars().nth(0).unwrap().is_uppercase());
+        AssistLabel { label: label.into(), id }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct AssistAction {
-    pub label: Option<String>,
     pub edit: TextEdit,
     pub cursor_position: Option<TextUnit>,
+    // FIXME: This belongs to `AssistLabel`
     pub target: Option<TextRange>,
 }
 
 #[derive(Debug, Clone)]
 pub struct ResolvedAssist {
     pub label: AssistLabel,
-    pub action_data: Either<AssistAction, Vec<AssistAction>>,
-}
-
-impl ResolvedAssist {
-    pub fn get_first_action(&self) -> AssistAction {
-        match &self.action_data {
-            Either::Left(action) => action.clone(),
-            Either::Right(actions) => actions[0].clone(),
-        }
-    }
+    pub group_label: Option<GroupLabel>,
+    pub action: AssistAction,
 }
 
 /// Return all the assists applicable at the given position.
 ///
 /// Assists are returned in the "unresolved" state, that is only labels are
 /// returned, without actual edits.
-pub fn applicable_assists<H>(db: &H, range: FileRange) -> Vec<AssistLabel>
-where
-    H: HirDatabase + 'static,
-{
-    AssistCtx::with_ctx(db, range, false, |ctx| {
-        assists::all()
-            .iter()
-            .filter_map(|f| f(ctx.clone()))
-            .map(|a| match a {
-                Assist::Unresolved { label } => label,
-                Assist::Resolved { .. } => unreachable!(),
-            })
-            .collect()
-    })
+pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabel> {
+    let ctx = AssistCtx::new(db, range, false);
+    handlers::all()
+        .iter()
+        .filter_map(|f| f(ctx.clone()))
+        .flat_map(|it| it.0)
+        .map(|a| a.label)
+        .collect()
 }
 
 /// Return all the assists applicable at the given position.
 ///
 /// Assists are returned in the "resolved" state, that is with edit fully
 /// computed.
-pub fn assists<H>(db: &H, range: FileRange) -> Vec<ResolvedAssist>
-where
-    H: HirDatabase + 'static,
-{
-    use std::cmp::Ordering;
-
-    AssistCtx::with_ctx(db, range, true, |ctx| {
-        let mut a = assists::all()
-            .iter()
-            .filter_map(|f| f(ctx.clone()))
-            .map(|a| match a {
-                Assist::Resolved { assist } => assist,
-                Assist::Unresolved { .. } => unreachable!(),
-            })
-            .collect::<Vec<_>>();
-        a.sort_by(|a, b| match (a.get_first_action().target, b.get_first_action().target) {
-            (Some(a), Some(b)) => a.len().cmp(&b.len()),
-            (Some(_), None) => Ordering::Less,
-            (None, Some(_)) => Ordering::Greater,
-            (None, None) => Ordering::Equal,
-        });
-        a
-    })
+pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssist> {
+    let ctx = AssistCtx::new(db, range, true);
+    let mut a = handlers::all()
+        .iter()
+        .filter_map(|f| f(ctx.clone()))
+        .flat_map(|it| it.0)
+        .map(|it| it.into_resolved().unwrap())
+        .collect::<Vec<_>>();
+    a.sort_by_key(|it| it.action.target.map_or(TextUnit::from(!0u32), |it| it.len()));
+    a
 }
 
-mod assists {
-    use crate::{Assist, AssistCtx};
-    use hir::db::HirDatabase;
+mod handlers {
+    use crate::AssistHandler;
 
     mod add_derive;
     mod add_explicit_type;
@@ -116,6 +97,7 @@ mod assists {
     mod add_custom_impl;
     mod add_new;
     mod apply_demorgan;
+    mod auto_import;
     mod invert_if;
     mod flip_comma;
     mod flip_binexpr;
@@ -129,13 +111,13 @@ mod assists {
     mod replace_if_let_with_match;
     mod split_import;
     mod remove_dbg;
-    pub(crate) mod add_import;
+    pub(crate) mod replace_qualified_name_with_use;
     mod add_missing_impl_members;
     mod move_guard;
     mod move_bounds;
     mod early_return;
 
-    pub(crate) fn all<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
+    pub(crate) fn all() -> &'static [AssistHandler] {
         &[
             add_derive::add_derive,
             add_explicit_type::add_explicit_type,
@@ -154,7 +136,7 @@ mod assists {
             replace_if_let_with_match::replace_if_let_with_match,
             split_import::split_import,
             remove_dbg::remove_dbg,
-            add_import::add_import,
+            replace_qualified_name_with_use::replace_qualified_name_with_use,
             add_missing_impl_members::add_missing_impl_members,
             add_missing_impl_members::add_missing_default_members,
             inline_local_variable::inline_local_variable,
@@ -166,33 +148,39 @@ mod assists {
             raw_string::make_usual_string,
             raw_string::remove_hash,
             early_return::convert_to_guarded_return,
+            auto_import::auto_import,
         ]
     }
 }
 
 #[cfg(test)]
 mod helpers {
-    use ra_db::{fixture::WithFixture, FileRange};
+    use std::sync::Arc;
+
+    use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
+    use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
     use ra_syntax::TextRange;
     use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
 
-    use crate::{test_db::TestDB, Assist, AssistCtx};
+    use crate::{AssistCtx, AssistHandler};
+
+    pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
+        let (mut db, file_id) = RootDatabase::with_single_file(text);
+        // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
+        // but it looks like this might need specialization? :(
+        let local_roots = vec![db.file_source_root(file_id)];
+        db.set_local_roots(Arc::new(local_roots));
+        (db, file_id)
+    }
 
-    pub(crate) fn check_assist(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-        after: &str,
-    ) {
+    pub(crate) fn check_assist(assist: AssistHandler, before: &str, after: &str) {
         let (before_cursor_pos, before) = extract_offset(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange =
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
         let assist =
-            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
+        let action = assist.0[0].action.clone().unwrap();
 
         let actual = action.edit.apply(&before);
         let actual_cursor_pos = match action.cursor_position {
@@ -206,20 +194,13 @@ mod helpers {
         assert_eq_text!(after, &actual);
     }
 
-    pub(crate) fn check_assist_range(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-        after: &str,
-    ) {
+    pub(crate) fn check_assist_range(assist: AssistHandler, before: &str, after: &str) {
         let (range, before) = extract_range(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange = FileRange { file_id, range };
         let assist =
-            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
+        let action = assist.0[0].action.clone().unwrap();
 
         let mut actual = action.edit.apply(&before);
         if let Some(pos) = action.cursor_position {
@@ -228,85 +209,65 @@ mod helpers {
         assert_eq_text!(after, &actual);
     }
 
-    pub(crate) fn check_assist_target(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-        target: &str,
-    ) {
+    pub(crate) fn check_assist_target(assist: AssistHandler, before: &str, target: &str) {
         let (before_cursor_pos, before) = extract_offset(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange =
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
         let assist =
-            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
+        let action = assist.0[0].action.clone().unwrap();
 
         let range = action.target.expect("expected target on action");
         assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
     }
 
-    pub(crate) fn check_assist_range_target(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-        target: &str,
-    ) {
+    pub(crate) fn check_assist_range_target(assist: AssistHandler, before: &str, target: &str) {
         let (range, before) = extract_range(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange = FileRange { file_id, range };
         let assist =
-            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
+        let action = assist.0[0].action.clone().unwrap();
 
         let range = action.target.expect("expected target on action");
         assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
     }
 
-    pub(crate) fn check_assist_not_applicable(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-    ) {
+    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, before: &str) {
         let (before_cursor_pos, before) = extract_offset(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange =
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
-        let assist = AssistCtx::with_ctx(&db, frange, true, assist);
+        let assist = assist(AssistCtx::new(&db, frange, true));
         assert!(assist.is_none());
     }
 
-    pub(crate) fn check_assist_range_not_applicable(
-        assist: fn(AssistCtx<TestDB>) -> Option<Assist>,
-        before: &str,
-    ) {
+    pub(crate) fn check_assist_range_not_applicable(assist: AssistHandler, before: &str) {
         let (range, before) = extract_range(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = with_single_file(&before);
         let frange = FileRange { file_id, range };
-        let assist = AssistCtx::with_ctx(&db, frange, true, assist);
+        let assist = assist(AssistCtx::new(&db, frange, true));
         assert!(assist.is_none());
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use ra_db::{fixture::WithFixture, FileRange};
+    use ra_db::FileRange;
     use ra_syntax::TextRange;
     use test_utils::{extract_offset, extract_range};
 
-    use crate::test_db::TestDB;
+    use crate::{helpers, resolved_assists};
 
     #[test]
     fn assist_order_field_struct() {
         let before = "struct Foo { <|>bar: u32 }";
         let (before_cursor_pos, before) = extract_offset(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = helpers::with_single_file(&before);
         let frange =
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
-        let assists = super::assists(&db, frange);
+        let assists = resolved_assists(&db, frange);
         let mut assists = assists.iter();
 
         assert_eq!(
@@ -327,9 +288,9 @@ mod tests {
             }
         }";
         let (range, before) = extract_range(before);
-        let (db, file_id) = TestDB::with_single_file(&before);
+        let (db, file_id) = helpers::with_single_file(&before);
         let frange = FileRange { file_id, range };
-        let assists = super::assists(&db, frange);
+        let assists = resolved_assists(&db, frange);
         let mut assists = assists.iter();
 
         assert_eq!(assists.next().expect("expected assist").label.label, "Extract into variable");
diff --git a/crates/ra_assists/src/test_db.rs b/crates/ra_assists/src/test_db.rs
deleted file mode 100644
index d5249f308..000000000
--- a/crates/ra_assists/src/test_db.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! Database used for testing `ra_assists`.
-
-use std::sync::Arc;
-
-use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
-
-#[salsa::database(
-    ra_db::SourceDatabaseExtStorage,
-    ra_db::SourceDatabaseStorage,
-    hir::db::InternDatabaseStorage,
-    hir::db::AstDatabaseStorage,
-    hir::db::DefDatabaseStorage,
-    hir::db::HirDatabaseStorage
-)]
-#[derive(Debug, Default)]
-pub struct TestDB {
-    runtime: salsa::Runtime<TestDB>,
-}
-
-impl salsa::Database for TestDB {
-    fn salsa_runtime(&self) -> &salsa::Runtime<Self> {
-        &self.runtime
-    }
-    fn salsa_runtime_mut(&mut self) -> &mut salsa::Runtime<Self> {
-        &mut self.runtime
-    }
-}
-
-impl std::panic::RefUnwindSafe for TestDB {}
-
-impl FileLoader for TestDB {
-    fn file_text(&self, file_id: FileId) -> Arc<String> {
-        FileLoaderDelegate(self).file_text(file_id)
-    }
-    fn resolve_relative_path(
-        &self,
-        anchor: FileId,
-        relative_path: &RelativePath,
-    ) -> Option<FileId> {
-        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
-    }
-    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
-        FileLoaderDelegate(self).relevant_crates(file_id)
-    }
-}
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
new file mode 100644
index 000000000..0d5722295
--- /dev/null
+++ b/crates/ra_assists/src/utils.rs
@@ -0,0 +1,27 @@
+//! Assorted functions shared by several assists.
+
+use ra_syntax::{
+    ast::{self, make},
+    T,
+};
+
+pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr {
+    if let Some(expr) = invert_special_case(&expr) {
+        return expr;
+    }
+    make::expr_prefix(T![!], expr)
+}
+
+fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
+    match expr {
+        ast::Expr::BinExpr(bin) => match bin.op_kind()? {
+            ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
+            ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()),
+            _ => None,
+        },
+        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => pe.expr(),
+        // FIXME:
+        // ast::Expr::Literal(true | false )
+        _ => None,
+    }
+}
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index e88295539..dd814fc9d 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -11,7 +11,8 @@ log = "0.4.3"
 cargo_metadata = "0.9.1"
 jod-thread = "0.1.0"
 parking_lot = "0.10.0"
+serde_json = "1.0.45"
 
 [dev-dependencies]
-insta = "0.12.0"
+insta = "0.13.0"
 serde_json = "1.0"
\ No newline at end of file
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_cargo_watch/src/conv.rs
index ac0f1d28a..506370535 100644
--- a/crates/ra_cargo_watch/src/conv.rs
+++ b/crates/ra_cargo_watch/src/conv.rs
@@ -1,12 +1,11 @@
 //! This module provides the functionality needed to convert diagnostics from
 //! `cargo check` json format to the LSP diagnostic format.
 use cargo_metadata::diagnostic::{
-    Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
-    DiagnosticSpanMacroExpansion,
+    Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion,
 };
 use lsp_types::{
-    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag, Location,
-    NumberOrString, Position, Range, Url,
+    CodeAction, Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag,
+    Location, NumberOrString, Position, Range, TextEdit, Url, WorkspaceEdit,
 };
 use std::{
     fmt::Write,
@@ -117,38 +116,9 @@ fn is_deprecated(rd: &RustDiagnostic) -> bool {
     }
 }
 
-#[derive(Debug)]
-pub struct SuggestedFix {
-    pub title: String,
-    pub location: Location,
-    pub replacement: String,
-    pub applicability: Applicability,
-    pub diagnostics: Vec<Diagnostic>,
-}
-
-impl std::cmp::PartialEq<SuggestedFix> for SuggestedFix {
-    fn eq(&self, other: &SuggestedFix) -> bool {
-        if self.title == other.title
-            && self.location == other.location
-            && self.replacement == other.replacement
-        {
-            // Applicability doesn't impl PartialEq...
-            match (&self.applicability, &other.applicability) {
-                (Applicability::MachineApplicable, Applicability::MachineApplicable) => true,
-                (Applicability::HasPlaceholders, Applicability::HasPlaceholders) => true,
-                (Applicability::MaybeIncorrect, Applicability::MaybeIncorrect) => true,
-                (Applicability::Unspecified, Applicability::Unspecified) => true,
-                _ => false,
-            }
-        } else {
-            false
-        }
-    }
-}
-
 enum MappedRustChildDiagnostic {
     Related(DiagnosticRelatedInformation),
-    SuggestedFix(SuggestedFix),
+    SuggestedFix(CodeAction),
     MessageLine(String),
 }
 
@@ -176,12 +146,20 @@ fn map_rust_child_diagnostic(
             rd.message.clone()
         };
 
-        MappedRustChildDiagnostic::SuggestedFix(SuggestedFix {
+        let edit = {
+            let edits = vec![TextEdit::new(location.range, suggested_replacement.clone())];
+            let mut edit_map = std::collections::HashMap::new();
+            edit_map.insert(location.uri, edits);
+            WorkspaceEdit::new(edit_map)
+        };
+
+        MappedRustChildDiagnostic::SuggestedFix(CodeAction {
             title,
-            location,
-            replacement: suggested_replacement.clone(),
-            applicability: span.suggestion_applicability.clone().unwrap_or(Applicability::Unknown),
-            diagnostics: vec![],
+            kind: Some("quickfix".to_string()),
+            diagnostics: None,
+            edit: Some(edit),
+            command: None,
+            is_preferred: None,
         })
     } else {
         MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
@@ -195,7 +173,7 @@ fn map_rust_child_diagnostic(
 pub(crate) struct MappedRustDiagnostic {
     pub location: Location,
     pub diagnostic: Diagnostic,
-    pub suggested_fixes: Vec<SuggestedFix>,
+    pub fixes: Vec<CodeAction>,
 }
 
 /// Converts a Rust root diagnostic to LSP form
@@ -250,15 +228,13 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         }
     }
 
-    let mut suggested_fixes = vec![];
+    let mut fixes = vec![];
     let mut message = rd.message.clone();
     for child in &rd.children {
         let child = map_rust_child_diagnostic(&child, workspace_root);
         match child {
             MappedRustChildDiagnostic::Related(related) => related_information.push(related),
-            MappedRustChildDiagnostic::SuggestedFix(suggested_fix) => {
-                suggested_fixes.push(suggested_fix)
-            }
+            MappedRustChildDiagnostic::SuggestedFix(code_action) => fixes.push(code_action.into()),
             MappedRustChildDiagnostic::MessageLine(message_line) => {
                 write!(&mut message, "\n{}", message_line).unwrap();
 
@@ -295,7 +271,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         tags: if !tags.is_empty() { Some(tags) } else { None },
     };
 
-    Some(MappedRustDiagnostic { location, diagnostic, suggested_fixes })
+    Some(MappedRustDiagnostic { location, diagnostic, fixes })
 }
 
 /// Returns a `Url` object from a given path, will lowercase drive letters if present.
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
index cb0920914..95ca163dc 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
@@ -61,25 +61,39 @@ MappedRustDiagnostic {
         ),
         tags: None,
     },
-    suggested_fixes: [
-        SuggestedFix {
+    fixes: [
+        CodeAction {
             title: "consider passing by value instead: \'self\'",
-            location: Location {
-                uri: "file:///test/compiler/mir/tagset.rs",
-                range: Range {
-                    start: Position {
-                        line: 41,
-                        character: 23,
-                    },
-                    end: Position {
-                        line: 41,
-                        character: 28,
-                    },
+            kind: Some(
+                "quickfix",
+            ),
+            diagnostics: None,
+            edit: Some(
+                WorkspaceEdit {
+                    changes: Some(
+                        {
+                            "file:///test/compiler/mir/tagset.rs": [
+                                TextEdit {
+                                    range: Range {
+                                        start: Position {
+                                            line: 41,
+                                            character: 23,
+                                        },
+                                        end: Position {
+                                            line: 41,
+                                            character: 28,
+                                        },
+                                    },
+                                    new_text: "self",
+                                },
+                            ],
+                        },
+                    ),
+                    document_changes: None,
                 },
-            },
-            replacement: "self",
-            applicability: Unspecified,
-            diagnostics: [],
+            ),
+            command: None,
+            is_preferred: None,
         },
     ],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
index 19510ecc1..12eb32df4 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
@@ -42,5 +42,5 @@ MappedRustDiagnostic {
         related_information: None,
         tags: None,
     },
-    suggested_fixes: [],
+    fixes: [],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_macro_compiler_error.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
index 92f7eec05..7b83a7cd0 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_macro_compiler_error.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
@@ -57,5 +57,5 @@ MappedRustDiagnostic {
         ),
         tags: None,
     },
-    suggested_fixes: [],
+    fixes: [],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
index cf683e4b6..54679c5db 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
@@ -42,5 +42,5 @@ MappedRustDiagnostic {
         related_information: None,
         tags: None,
     },
-    suggested_fixes: [],
+    fixes: [],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
index 8c1483c74..57df4ceaf 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
@@ -42,5 +42,5 @@ MappedRustDiagnostic {
         related_information: None,
         tags: None,
     },
-    suggested_fixes: [],
+    fixes: [],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
index eb5a2247b..3e1fe736c 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
@@ -46,25 +46,39 @@ MappedRustDiagnostic {
             ],
         ),
     },
-    suggested_fixes: [
-        SuggestedFix {
+    fixes: [
+        CodeAction {
             title: "consider prefixing with an underscore: \'_foo\'",
-            location: Location {
-                uri: "file:///test/driver/subcommand/repl.rs",
-                range: Range {
-                    start: Position {
-                        line: 290,
-                        character: 8,
-                    },
-                    end: Position {
-                        line: 290,
-                        character: 11,
-                    },
+            kind: Some(
+                "quickfix",
+            ),
+            diagnostics: None,
+            edit: Some(
+                WorkspaceEdit {
+                    changes: Some(
+                        {
+                            "file:///test/driver/subcommand/repl.rs": [
+                                TextEdit {
+                                    range: Range {
+                                        start: Position {
+                                            line: 290,
+                                            character: 8,
+                                        },
+                                        end: Position {
+                                            line: 290,
+                                            character: 11,
+                                        },
+                                    },
+                                    new_text: "_foo",
+                                },
+                            ],
+                        },
+                    ),
+                    document_changes: None,
                 },
-            },
-            replacement: "_foo",
-            applicability: MachineApplicable,
-            diagnostics: [],
+            ),
+            command: None,
+            is_preferred: None,
         },
     ],
 }
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
index 2f4518931..69301078d 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
@@ -61,5 +61,5 @@ MappedRustDiagnostic {
         ),
         tags: None,
     },
-    suggested_fixes: [],
+    fixes: [],
 }
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
index 7f4c9280c..f07c34549 100644
--- a/crates/ra_cargo_watch/src/lib.rs
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -4,22 +4,20 @@
 use cargo_metadata::Message;
 use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
 use lsp_types::{
-    Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin, WorkDoneProgressEnd,
-    WorkDoneProgressReport,
+    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
+    WorkDoneProgressEnd, WorkDoneProgressReport,
 };
-use parking_lot::RwLock;
 use std::{
-    collections::HashMap,
+    io::{BufRead, BufReader},
     path::PathBuf,
     process::{Command, Stdio},
-    sync::Arc,
     thread::JoinHandle,
     time::Instant,
 };
 
 mod conv;
 
-use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic, SuggestedFix};
+use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
 
 pub use crate::conv::url_from_path_with_drive_lowercasing;
 
@@ -38,7 +36,6 @@ pub struct CheckOptions {
 #[derive(Debug)]
 pub struct CheckWatcher {
     pub task_recv: Receiver<CheckTask>,
-    pub state: Arc<RwLock<CheckState>>,
     cmd_send: Option<Sender<CheckCommand>>,
     handle: Option<JoinHandle<()>>,
 }
@@ -46,7 +43,6 @@ pub struct CheckWatcher {
 impl CheckWatcher {
     pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
         let options = options.clone();
-        let state = Arc::new(RwLock::new(CheckState::new()));
 
         let (task_send, task_recv) = unbounded::<CheckTask>();
         let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
@@ -54,13 +50,12 @@ impl CheckWatcher {
             let mut check = CheckWatcherThread::new(options, workspace_root);
             check.run(&task_send, &cmd_recv);
         });
-        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle), state }
+        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle) }
     }
 
     /// Returns a CheckWatcher that doesn't actually do anything
     pub fn dummy() -> CheckWatcher {
-        let state = Arc::new(RwLock::new(CheckState::new()));
-        CheckWatcher { task_recv: never(), cmd_send: None, handle: None, state }
+        CheckWatcher { task_recv: never(), cmd_send: None, handle: None }
     }
 
     /// Schedule a re-start of the cargo check worker.
@@ -88,83 +83,12 @@ impl std::ops::Drop for CheckWatcher {
 }
 
 #[derive(Debug)]
-pub struct CheckState {
-    diagnostic_collection: HashMap<Url, Vec<Diagnostic>>,
-    suggested_fix_collection: HashMap<Url, Vec<SuggestedFix>>,
-}
-
-impl CheckState {
-    fn new() -> CheckState {
-        CheckState {
-            diagnostic_collection: HashMap::new(),
-            suggested_fix_collection: HashMap::new(),
-        }
-    }
-
-    /// Clear the cached diagnostics, and schedule updating diagnostics by the
-    /// server, to clear stale results.
-    pub fn clear(&mut self) -> Vec<Url> {
-        let cleared_files: Vec<Url> = self.diagnostic_collection.keys().cloned().collect();
-        self.diagnostic_collection.clear();
-        self.suggested_fix_collection.clear();
-        cleared_files
-    }
-
-    pub fn diagnostics_for(&self, uri: &Url) -> Option<&[Diagnostic]> {
-        self.diagnostic_collection.get(uri).map(|d| d.as_slice())
-    }
-
-    pub fn fixes_for(&self, uri: &Url) -> Option<&[SuggestedFix]> {
-        self.suggested_fix_collection.get(uri).map(|d| d.as_slice())
-    }
-
-    pub fn add_diagnostic_with_fixes(&mut self, file_uri: Url, diagnostic: DiagnosticWithFixes) {
-        for fix in diagnostic.suggested_fixes {
-            self.add_suggested_fix_for_diagnostic(fix, &diagnostic.diagnostic);
-        }
-        self.add_diagnostic(file_uri, diagnostic.diagnostic);
-    }
-
-    fn add_diagnostic(&mut self, file_uri: Url, diagnostic: Diagnostic) {
-        let diagnostics = self.diagnostic_collection.entry(file_uri).or_default();
-
-        // If we're building multiple targets it's possible we've already seen this diagnostic
-        let is_duplicate = diagnostics.iter().any(|d| are_diagnostics_equal(d, &diagnostic));
-        if is_duplicate {
-            return;
-        }
-
-        diagnostics.push(diagnostic);
-    }
-
-    fn add_suggested_fix_for_diagnostic(
-        &mut self,
-        mut suggested_fix: SuggestedFix,
-        diagnostic: &Diagnostic,
-    ) {
-        let file_uri = suggested_fix.location.uri.clone();
-        let file_suggestions = self.suggested_fix_collection.entry(file_uri).or_default();
-
-        let existing_suggestion: Option<&mut SuggestedFix> =
-            file_suggestions.iter_mut().find(|s| s == &&suggested_fix);
-        if let Some(existing_suggestion) = existing_suggestion {
-            // The existing suggestion also applies to this new diagnostic
-            existing_suggestion.diagnostics.push(diagnostic.clone());
-        } else {
-            // We haven't seen this suggestion before
-            suggested_fix.diagnostics.push(diagnostic.clone());
-            file_suggestions.push(suggested_fix);
-        }
-    }
-}
-
-#[derive(Debug)]
 pub enum CheckTask {
     /// Request a clearing of all cached diagnostics from the check watcher
     ClearDiagnostics,
 
     /// Request adding a diagnostic with fixes included to a file
-    AddDiagnostic(Url, DiagnosticWithFixes),
+    AddDiagnostic { url: Url, diagnostic: Diagnostic, fixes: Vec<CodeActionOrCommand> },
 
     /// Request check progress notification to client
     Status(WorkDoneProgress),
@@ -216,8 +140,10 @@ impl CheckWatcherThread {
                 self.last_update_req.take();
                 task_send.send(CheckTask::ClearDiagnostics).unwrap();
 
-                // By replacing the watcher, we drop the previous one which
-                // causes it to shut down automatically.
+                // Replace with a dummy watcher first so we drop the original and wait for completion
+                std::mem::replace(&mut self.watcher, WatchThread::dummy());
+
+                // Then create the actual new watcher
                 self.watcher = WatchThread::new(&self.options, &self.workspace_root);
             }
         }
@@ -277,10 +203,17 @@ impl CheckWatcherThread {
                         None => return,
                     };
 
-                let MappedRustDiagnostic { location, diagnostic, suggested_fixes } = map_result;
+                let MappedRustDiagnostic { location, diagnostic, fixes } = map_result;
+                let fixes = fixes
+                    .into_iter()
+                    .map(|fix| {
+                        CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
+                    })
+                    .collect();
 
-                let diagnostic = DiagnosticWithFixes { diagnostic, suggested_fixes };
-                task_send.send(CheckTask::AddDiagnostic(location.uri, diagnostic)).unwrap();
+                task_send
+                    .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
+                    .unwrap();
             }
 
             CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
@@ -292,7 +225,7 @@ impl CheckWatcherThread {
 #[derive(Debug)]
 pub struct DiagnosticWithFixes {
     diagnostic: Diagnostic,
-    suggested_fixes: Vec<SuggestedFix>,
+    fixes: Vec<CodeAction>,
 }
 
 /// WatchThread exists to wrap around the communication needed to be able to
@@ -341,6 +274,7 @@ impl WatchThread {
                 .args(&args)
                 .stdout(Stdio::piped())
                 .stderr(Stdio::null())
+                .stdin(Stdio::null())
                 .spawn()
                 .expect("couldn't launch cargo");
 
@@ -348,15 +282,45 @@ impl WatchThread {
             // which will break out of the loop, and continue the shutdown
             let _ = message_send.send(CheckEvent::Begin);
 
-            for message in cargo_metadata::parse_messages(command.stdout.take().unwrap()) {
+            // We manually read a line at a time, instead of using serde's
+            // stream deserializers, because the deserializer cannot recover
+            // from an error, resulting in it getting stuck, because we try to
+            // be resillient against failures.
+            //
+            // Because cargo only outputs one JSON object per line, we can
+            // simply skip a line if it doesn't parse, which just ignores any
+            // erroneus output.
+            let stdout = BufReader::new(command.stdout.take().unwrap());
+            for line in stdout.lines() {
+                let line = match line {
+                    Ok(line) => line,
+                    Err(err) => {
+                        log::error!("Couldn't read line from cargo: {}", err);
+                        continue;
+                    }
+                };
+
+                let message = serde_json::from_str::<cargo_metadata::Message>(&line);
                 let message = match message {
                     Ok(message) => message,
                     Err(err) => {
-                        log::error!("Invalid json from cargo check, ignoring: {}", err);
+                        log::error!(
+                            "Invalid json from cargo check, ignoring ({}): {:?} ",
+                            err,
+                            line
+                        );
                         continue;
                     }
                 };
 
+                // Skip certain kinds of messages to only spend time on what's useful
+                match &message {
+                    Message::CompilerArtifact(artifact) if artifact.fresh => continue,
+                    Message::BuildScriptExecuted(_) => continue,
+                    Message::Unknown => continue,
+                    _ => {}
+                }
+
                 match message_send.send(CheckEvent::Msg(message)) {
                     Ok(()) => {}
                     Err(_err) => {
@@ -396,10 +360,3 @@ impl std::ops::Drop for WatchThread {
         }
     }
 }
-
-fn are_diagnostics_equal(left: &Diagnostic, right: &Diagnostic) -> bool {
-    left.source == right.source
-        && left.severity == right.severity
-        && left.range == right.range
-        && left.message == right.message
-}
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 12af075f7..bcd408421 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -7,7 +7,7 @@ publish = false
 
 [dependencies]
 pico-args = "0.3.0"
-env_logger = { version = "0.7.1", default-features = false, features = ["humantime"] }
+env_logger = { version = "0.7.1", default-features = false }
 
 ra_syntax = { path = "../ra_syntax" }
 ra_ide = { path = "../ra_ide" }
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index fd0027691..833235bff 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -171,12 +171,12 @@ pub fn run(
     println!(
         "Expressions of unknown type: {} ({}%)",
         num_exprs_unknown,
-        if num_exprs > 0 { (num_exprs_unknown * 100 / num_exprs) } else { 100 }
+        if num_exprs > 0 { num_exprs_unknown * 100 / num_exprs } else { 100 }
     );
     println!(
         "Expressions of partially unknown type: {} ({}%)",
         num_exprs_partially_unknown,
-        if num_exprs > 0 { (num_exprs_partially_unknown * 100 / num_exprs) } else { 100 }
+        if num_exprs > 0 { num_exprs_partially_unknown * 100 / num_exprs } else { 100 }
     );
     println!("Type mismatches: {}", num_type_mismatches);
     println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 30b598e9a..17cd138c2 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -8,8 +8,8 @@ use rustc_hash::FxHashMap;
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
 
 use crate::{
-    CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf, SourceDatabaseExt,
-    SourceRoot, SourceRootId,
+    input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf,
+    SourceDatabaseExt, SourceRoot, SourceRootId,
 };
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
@@ -139,7 +139,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
         for (from, to) in crate_deps {
             let from_id = crates[&from];
             let to_id = crates[&to];
-            crate_graph.add_dep(from_id, to.into(), to_id).unwrap();
+            crate_graph.add_dep(from_id, CrateName::new(&to).unwrap(), to_id).unwrap();
         }
     }
 
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 07269237a..1f1dcea42 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -83,6 +83,26 @@ pub struct CrateGraph {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateId(pub u32);
 
+pub struct CrateName(SmolStr);
+
+impl CrateName {
+    /// Crates a crate name, checking for dashes in the string provided.
+    /// Dashes are not allowed in the crate names,
+    /// hence the input string is returned as `Err` for those cases.
+    pub fn new(name: &str) -> Result<CrateName, &str> {
+        if name.contains('-') {
+            Err(name)
+        } else {
+            Ok(Self(SmolStr::new(name)))
+        }
+    }
+
+    /// Crates a crate name, unconditionally replacing the dashes with underscores.
+    pub fn normalize_dashes(name: &str) -> CrateName {
+        Self(SmolStr::new(name.replace('-', "_")))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct CrateData {
     file_id: FileId,
@@ -131,13 +151,13 @@ impl CrateGraph {
     pub fn add_dep(
         &mut self,
         from: CrateId,
-        name: SmolStr,
+        name: CrateName,
         to: CrateId,
     ) -> Result<(), CyclicDependenciesError> {
         if self.dfs_find(from, to, &mut FxHashSet::default()) {
             return Err(CyclicDependenciesError);
         }
-        self.arena.get_mut(&from).unwrap().add_dep(name, to);
+        self.arena.get_mut(&from).unwrap().add_dep(name.0, to);
         Ok(())
     }
 
@@ -268,7 +288,7 @@ pub struct CyclicDependenciesError;
 
 #[cfg(test)]
 mod tests {
-    use super::{CfgOptions, CrateGraph, Edition::Edition2018, Env, FileId, SmolStr};
+    use super::{CfgOptions, CrateGraph, CrateName, Dependency, Edition::Edition2018, Env, FileId};
 
     #[test]
     fn it_should_panic_because_of_cycle_dependencies() {
@@ -279,9 +299,9 @@ mod tests {
             graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
         let crate3 =
             graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
-        assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
-        assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
-        assert!(graph.add_dep(crate3, SmolStr::new("crate1"), crate1).is_err());
+        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
+        assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
+        assert!(graph.add_dep(crate3, CrateName::new("crate1").unwrap(), crate1).is_err());
     }
 
     #[test]
@@ -293,7 +313,23 @@ mod tests {
             graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
         let crate3 =
             graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
-        assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
-        assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
+        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
+        assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
+    }
+
+    #[test]
+    fn dashes_are_normalized() {
+        let mut graph = CrateGraph::default();
+        let crate1 =
+            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate2 =
+            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+        assert!(graph
+            .add_dep(crate1, CrateName::normalize_dashes("crate-name-with-dashes"), crate2)
+            .is_ok());
+        assert_eq!(
+            graph.dependencies(crate1).collect::<Vec<_>>(),
+            vec![&Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
+        );
     }
 }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 21341b769..fb002d717 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -10,7 +10,9 @@ use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
 
 pub use crate::{
     cancellation::Canceled,
-    input::{CrateGraph, CrateId, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId},
+    input::{
+        CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId,
+    },
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
 pub use salsa;
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index 10f592257..4bca27b5c 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -35,8 +35,14 @@ fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
     successors(token.prev_token(), |token| token.prev_token())
 }
 
-pub fn extract_trivial_expression(expr: &ast::BlockExpr) -> Option<ast::Expr> {
-    let block = expr.block()?;
+pub fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
+    extract_trivial_expression(&block)
+        .filter(|expr| !expr.syntax().text().contains_char('\n'))
+        .unwrap_or_else(|| block.into())
+}
+
+pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
+    let block = block.block()?;
     let expr = block.expr()?;
     let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
         WHITESPACE | T!['{'] | T!['}'] => false,
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 500b34c17..4d9641728 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -10,9 +10,9 @@ use hir_def::{
     per_ns::PerNs,
     resolver::HasResolver,
     type_ref::{Mutability, TypeRef},
-    AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId,
-    LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
-    TypeParamId, UnionId,
+    AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId,
+    LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId,
+    TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 use hir_expand::{
     diagnostics::DiagnosticSink,
@@ -21,7 +21,7 @@ use hir_expand::{
 };
 use hir_ty::{
     autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
-    Canonical, InEnvironment, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+    Canonical, InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -119,7 +119,7 @@ impl_froms!(
     BuiltinType
 );
 
-pub use hir_def::{attr::Attrs, visibility::Visibility, AssocItemId};
+pub use hir_def::{attr::Attrs, item_scope::ItemInNs, visibility::Visibility, AssocItemId};
 use rustc_hash::FxHashSet;
 
 impl Module {
@@ -238,11 +238,16 @@ impl Module {
         item: ModuleDef,
     ) -> Option<hir_def::path::ModPath> {
         // FIXME expose namespace choice
-        hir_def::find_path::find_path(
-            db,
-            hir_def::item_scope::ItemInNs::Types(item.into()),
-            self.into(),
-        )
+        hir_def::find_path::find_path(db, determine_item_namespace(item), self.into())
+    }
+}
+
+fn determine_item_namespace(module_def: ModuleDef) -> ItemInNs {
+    match module_def {
+        ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
+            ItemInNs::Values(module_def.into())
+        }
+        _ => ItemInNs::Types(module_def.into()),
     }
 }
 
@@ -265,7 +270,13 @@ impl StructField {
 
     pub fn ty(&self, db: &impl HirDatabase) -> Type {
         let var_id = self.parent.into();
-        let ty = db.field_types(var_id)[self.id].clone();
+        let generic_def_id: GenericDefId = match self.parent {
+            VariantDef::Struct(it) => it.id.into(),
+            VariantDef::Union(it) => it.id.into(),
+            VariantDef::EnumVariant(it) => it.parent.id.into(),
+        };
+        let substs = Substs::type_params(db, generic_def_id);
+        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
         Type::new(db, self.parent.module(db).id.krate.into(), var_id, ty)
     }
 
@@ -750,7 +761,7 @@ pub struct TypeParam {
 impl TypeParam {
     pub fn name(self, db: &impl HirDatabase) -> Name {
         let params = db.generic_params(self.id.parent);
-        params.types[self.id.local_id].name.clone()
+        params.types[self.id.local_id].name.clone().unwrap_or_else(Name::missing)
     }
 
     pub fn module(self, db: &impl HirDatabase) -> Module {
@@ -784,8 +795,9 @@ impl ImplBlock {
     pub fn target_ty(&self, db: &impl HirDatabase) -> Type {
         let impl_data = db.impl_data(self.id);
         let resolver = self.id.resolver(db);
+        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
         let environment = TraitEnvironment::lower(db, &resolver);
-        let ty = Ty::from_hir(db, &resolver, &impl_data.target_type);
+        let ty = Ty::from_hir(&ctx, &impl_data.target_type);
         Type {
             krate: self.id.lookup(db).container.module(db).krate,
             ty: InEnvironment { value: ty, environment },
@@ -846,9 +858,10 @@ impl Type {
     fn from_def(
         db: &impl HirDatabase,
         krate: CrateId,
-        def: impl HasResolver + Into<TyDefId>,
+        def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
     ) -> Type {
-        let ty = db.ty(def.into());
+        let substs = Substs::type_params(db, def);
+        let ty = db.ty(def.into()).subst(&substs);
         Type::new(db, krate, def, ty)
     }
 
@@ -945,7 +958,7 @@ impl Type {
             match a_ty.ctor {
                 TypeCtor::Tuple { .. } => {
                     for ty in a_ty.parameters.iter() {
-                        let ty = ty.clone().subst(&a_ty.parameters);
+                        let ty = ty.clone();
                         res.push(self.derived(ty));
                     }
                 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index e6079b88d..a77bf6de6 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,20 +1,24 @@
 //! FIXME: write short doc here
 
 pub use hir_def::db::{
-    BodyQuery, BodyWithSourceMapQuery, ComputeCrateDefMapQuery, ConstDataQuery,
+    AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ComputeCrateDefMapQuery, ConstDataQuery,
     CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery,
-    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase,
-    InternDatabaseStorage, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, StaticDataQuery,
-    StructDataQuery, TraitDataQuery, TypeAliasDataQuery,
+    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternConstQuery,
+    InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
+    InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery, InternUnionQuery,
+    LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, StaticDataQuery, StructDataQuery,
+    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
-    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
-    ParseMacroQuery,
+    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternMacroQuery, MacroArgQuery, MacroDefQuery,
+    MacroExpandQuery, ParseMacroQuery,
 };
 pub use hir_ty::db::{
-    AssociatedTyDataQuery, CallableItemSignatureQuery, DoInferQuery, FieldTypesQuery,
-    GenericDefaultsQuery, GenericPredicatesQuery, HirDatabase, HirDatabaseStorage, ImplDatumQuery,
-    ImplsForTraitQuery, ImplsInCrateQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery,
+    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, DoInferQuery,
+    FieldTypesQuery, GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery,
+    HirDatabase, HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery,
+    ImplsForTraitQuery, ImplsInCrateQuery, InternAssocTyValueQuery, InternChalkImplQuery,
+    InternTypeCtorQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery, TraitSolverQuery,
     TyQuery, ValueTyQuery,
 };
 
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 4f8fc9602..bb9a35c5d 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -178,6 +178,10 @@ impl SourceAnalyzer {
         }
     }
 
+    fn trait_env(&self, db: &impl HirDatabase) -> Arc<TraitEnvironment> {
+        TraitEnvironment::lower(db, &self.resolver)
+    }
+
     pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
         let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
             self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
@@ -186,14 +190,14 @@ impl SourceAnalyzer {
         };
 
         let ty = self.infer.as_ref()?[expr_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
+        let environment = self.trait_env(db);
         Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
     }
 
     pub fn type_of_pat(&self, db: &impl HirDatabase, pat: &ast::Pat) -> Option<Type> {
         let pat_id = self.pat_id(pat)?;
         let ty = self.infer.as_ref()?[pat_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
+        let environment = self.trait_env(db);
         Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
     }
 
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index 2c368f690..1efa00fe0 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -26,4 +26,4 @@ ra_cfg = { path = "../ra_cfg" }
 tt = { path = "../ra_tt", package = "ra_tt" }
 
 [dev-dependencies]
-insta = "0.12.0"
+insta = "0.13.0"
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 8cc2fb160..43b9b124a 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -7,10 +7,39 @@ use crate::{
     visibility::Visibility,
     CrateId, ModuleDefId, ModuleId,
 };
-use hir_expand::name::Name;
+use hir_expand::name::{known, Name};
+use test_utils::tested_by;
 
 const MAX_PATH_LEN: usize = 15;
 
+impl ModPath {
+    fn starts_with_std(&self) -> bool {
+        self.segments.first().filter(|&first_segment| first_segment == &known::std).is_some()
+    }
+
+    // When std library is present, paths starting with `std::`
+    // should be preferred over paths starting with `core::` and `alloc::`
+    fn should_start_with_std(&self) -> bool {
+        self.segments
+            .first()
+            .filter(|&first_segment| {
+                first_segment == &known::alloc || first_segment == &known::core
+            })
+            .is_some()
+    }
+
+    fn len(&self) -> usize {
+        self.segments.len()
+            + match self.kind {
+                PathKind::Plain => 0,
+                PathKind::Super(i) => i as usize,
+                PathKind::Crate => 1,
+                PathKind::Abs => 0,
+                PathKind::DollarCrate(_) => 1,
+            }
+    }
+}
+
 // FIXME: handle local items
 
 /// Find a path that can be used to refer to a certain item. This can depend on
@@ -112,23 +141,27 @@ fn find_path_inner(
             Some(path) => path,
         };
         path.segments.push(name);
-        if path_len(&path) < best_path_len {
-            best_path_len = path_len(&path);
-            best_path = Some(path);
-        }
+
+        let new_path =
+            if let Some(best_path) = best_path { select_best_path(best_path, path) } else { path };
+        best_path_len = new_path.len();
+        best_path = Some(new_path);
     }
     best_path
 }
 
-fn path_len(path: &ModPath) -> usize {
-    path.segments.len()
-        + match path.kind {
-            PathKind::Plain => 0,
-            PathKind::Super(i) => i as usize,
-            PathKind::Crate => 1,
-            PathKind::Abs => 0,
-            PathKind::DollarCrate(_) => 1,
-        }
+fn select_best_path(old_path: ModPath, new_path: ModPath) -> ModPath {
+    if old_path.starts_with_std() && new_path.should_start_with_std() {
+        tested_by!(prefer_std_paths);
+        old_path
+    } else if new_path.starts_with_std() && old_path.should_start_with_std() {
+        tested_by!(prefer_std_paths);
+        new_path
+    } else if new_path.len() < old_path.len() {
+        new_path
+    } else {
+        old_path
+    }
 }
 
 fn find_importable_locations(
@@ -201,6 +234,7 @@ mod tests {
     use hir_expand::hygiene::Hygiene;
     use ra_db::fixture::WithFixture;
     use ra_syntax::ast::AstNode;
+    use test_utils::covers;
 
     /// `code` needs to contain a cursor marker; checks that `find_path` for the
     /// item the `path` refers to returns that same path when called from the
@@ -452,4 +486,41 @@ mod tests {
         "#;
         check_found_path(code, "crate::foo::S");
     }
+
+    #[test]
+    fn prefer_std_paths_over_alloc() {
+        covers!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:alloc,std
+        <|>
+
+        //- /std.rs crate:std deps:alloc
+        pub mod sync {
+            pub use alloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:alloc
+        pub mod sync {
+            pub struct Arc;
+        }
+        "#;
+        check_found_path(code, "std::sync::Arc");
+    }
+
+    #[test]
+    fn prefer_shorter_paths_if_not_alloc() {
+        let code = r#"
+        //- /main.rs crate:main deps:megaalloc,std
+        <|>
+
+        //- /std.rs crate:std deps:megaalloc
+        pub mod sync {
+            pub use megaalloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:megaalloc
+        pub struct Arc;
+        "#;
+        check_found_path(code, "megaalloc::Arc");
+    }
 }
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index e9c28c730..f765e6edc 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -27,8 +27,16 @@ use crate::{
 /// Data about a generic parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TypeParamData {
-    pub name: Name,
+    pub name: Option<Name>,
     pub default: Option<TypeRef>,
+    pub provenance: TypeParamProvenance,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum TypeParamProvenance {
+    TypeParamList,
+    TraitSelf,
+    ArgumentImplTrait,
 }
 
 /// Data about the generic parameters of a function, struct, impl, etc.
@@ -45,10 +53,17 @@ pub struct GenericParams {
 /// associated type bindings like `Iterator<Item = u32>`.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct WherePredicate {
-    pub type_ref: TypeRef,
+    pub target: WherePredicateTarget,
     pub bound: TypeBound,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum WherePredicateTarget {
+    TypeRef(TypeRef),
+    /// For desugared where predicates that can directly refer to a type param.
+    TypeParam(LocalTypeParamId),
+}
+
 type SourceMap = ArenaMap<LocalTypeParamId, Either<ast::TraitDef, ast::TypeParam>>;
 
 impl GenericParams {
@@ -68,6 +83,11 @@ impl GenericParams {
             GenericDefId::FunctionId(it) => {
                 let src = it.lookup(db).source(db);
                 generics.fill(&mut sm, &src.value);
+                // lower `impl Trait` in arguments
+                let data = db.function_data(it);
+                for param in &data.params {
+                    generics.fill_implicit_impl_trait_args(param);
+                }
                 src.file_id
             }
             GenericDefId::AdtId(AdtId::StructId(it)) => {
@@ -89,8 +109,11 @@ impl GenericParams {
                 let src = it.lookup(db).source(db);
 
                 // traits get the Self type as an implicit first type parameter
-                let self_param_id =
-                    generics.types.alloc(TypeParamData { name: name![Self], default: None });
+                let self_param_id = generics.types.alloc(TypeParamData {
+                    name: Some(name![Self]),
+                    default: None,
+                    provenance: TypeParamProvenance::TraitSelf,
+                });
                 sm.insert(self_param_id, Either::Left(src.value.clone()));
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
@@ -142,7 +165,11 @@ impl GenericParams {
             let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
             // FIXME: Use `Path::from_src`
             let default = type_param.default_type().map(TypeRef::from_ast);
-            let param = TypeParamData { name: name.clone(), default };
+            let param = TypeParamData {
+                name: Some(name.clone()),
+                default,
+                provenance: TypeParamProvenance::TypeParamList,
+            };
             let param_id = self.types.alloc(param);
             sm.insert(param_id, Either::Right(type_param.clone()));
 
@@ -170,11 +197,43 @@ impl GenericParams {
             return;
         }
         let bound = TypeBound::from_ast(bound);
-        self.where_predicates.push(WherePredicate { type_ref, bound });
+        self.where_predicates
+            .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
+    }
+
+    fn fill_implicit_impl_trait_args(&mut self, type_ref: &TypeRef) {
+        type_ref.walk(&mut |type_ref| {
+            if let TypeRef::ImplTrait(bounds) = type_ref {
+                let param = TypeParamData {
+                    name: None,
+                    default: None,
+                    provenance: TypeParamProvenance::ArgumentImplTrait,
+                };
+                let param_id = self.types.alloc(param);
+                for bound in bounds {
+                    self.where_predicates.push(WherePredicate {
+                        target: WherePredicateTarget::TypeParam(param_id),
+                        bound: bound.clone(),
+                    });
+                }
+            }
+        });
     }
 
     pub fn find_by_name(&self, name: &Name) -> Option<LocalTypeParamId> {
-        self.types.iter().find_map(|(id, p)| if &p.name == name { Some(id) } else { None })
+        self.types
+            .iter()
+            .find_map(|(id, p)| if p.name.as_ref() == Some(name) { Some(id) } else { None })
+    }
+
+    pub fn find_trait_self_param(&self) -> Option<LocalTypeParamId> {
+        self.types.iter().find_map(|(id, p)| {
+            if p.provenance == TypeParamProvenance::TraitSelf {
+                Some(id)
+            } else {
+                None
+            }
+        })
     }
 }
 
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
index 457ba4abe..daa49d5f1 100644
--- a/crates/ra_hir_def/src/marks.rs
+++ b/crates/ra_hir_def/src/marks.rs
@@ -13,4 +13,5 @@ test_utils::marks!(
     macro_dollar_crate_self
     macro_dollar_crate_other
     infer_resolve_while_let
+    prefer_std_paths
 );
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 27c12e46c..852304dd0 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -229,6 +229,46 @@ impl CrateDefMap {
             self.resolve_path_fp_with_macro(db, ResolveMode::Other, original_module, path, shadow);
         (res.resolved_def, res.segment_index)
     }
+
+    // FIXME: this can use some more human-readable format (ideally, an IR
+    // even), as this should be a great debugging aid.
+    pub fn dump(&self) -> String {
+        let mut buf = String::new();
+        go(&mut buf, self, "\ncrate", self.root);
+        return buf.trim().to_string();
+
+        fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
+            *buf += path;
+            *buf += "\n";
+
+            let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
+            entries.sort_by_key(|(name, _)| name.clone());
+
+            for (name, def) in entries {
+                *buf += &format!("{}:", name);
+
+                if def.types.is_some() {
+                    *buf += " t";
+                }
+                if def.values.is_some() {
+                    *buf += " v";
+                }
+                if def.macros.is_some() {
+                    *buf += " m";
+                }
+                if def.is_none() {
+                    *buf += " _";
+                }
+
+                *buf += "\n";
+            }
+
+            for (name, child) in map.modules[module].children.iter() {
+                let path = path.to_string() + &format!("::{}", name);
+                go(buf, map, &path, *child);
+            }
+        }
+    }
 }
 
 impl ModuleData {
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 7499dff31..6352c71ef 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -22,7 +22,7 @@ use crate::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
         raw, BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
     },
-    path::{ModPath, PathKind},
+    path::{ImportAlias, ModPath, PathKind},
     per_ns::PerNs,
     visibility::Visibility,
     AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
@@ -438,7 +438,11 @@ where
         } else {
             match import.path.segments.last() {
                 Some(last_segment) => {
-                    let name = import.alias.clone().unwrap_or_else(|| last_segment.clone());
+                    let name = match &import.alias {
+                        Some(ImportAlias::Alias(name)) => name.clone(),
+                        Some(ImportAlias::Underscore) => last_segment.clone(), // FIXME rust-analyzer#2736
+                        None => last_segment.clone(),
+                    };
                     log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
 
                     // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index fac1169ef..650cf1f98 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -22,8 +22,11 @@ use ra_syntax::{
 use test_utils::tested_by;
 
 use crate::{
-    attr::Attrs, db::DefDatabase, path::ModPath, visibility::RawVisibility, FileAstId, HirFileId,
-    InFile,
+    attr::Attrs,
+    db::DefDatabase,
+    path::{ImportAlias, ModPath},
+    visibility::RawVisibility,
+    FileAstId, HirFileId, InFile,
 };
 
 /// `RawItems` is a set of top-level items in a file (except for impls).
@@ -145,7 +148,7 @@ impl_arena_id!(Import);
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportData {
     pub(super) path: ModPath,
-    pub(super) alias: Option<Name>,
+    pub(super) alias: Option<ImportAlias>,
     pub(super) is_glob: bool,
     pub(super) is_prelude: bool,
     pub(super) is_extern_crate: bool,
@@ -353,7 +356,11 @@ impl RawItemsCollector {
             let path = ModPath::from_name_ref(&name_ref);
             let visibility =
                 RawVisibility::from_ast_with_hygiene(extern_crate.visibility(), &self.hygiene);
-            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
+            let alias = extern_crate.alias().map(|a| {
+                a.name()
+                    .map(|it| it.as_name())
+                    .map_or(ImportAlias::Underscore, |a| ImportAlias::Alias(a))
+            });
             let attrs = self.parse_attrs(&extern_crate);
             // FIXME: cfg_attr
             let is_macro_use = extern_crate.has_atom_attr("macro_use");
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 78bcdc850..82f0f835c 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -10,11 +10,10 @@ use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, SourceDatabase};
 use test_utils::covers;
 
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
 fn def_map(fixture: &str) -> String {
-    let dm = compute_crate_def_map(fixture);
-    render_crate_def_map(&dm)
+    compute_crate_def_map(fixture).dump()
 }
 
 fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
@@ -23,44 +22,6 @@ fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
     db.crate_def_map(krate)
 }
 
-fn render_crate_def_map(map: &CrateDefMap) -> String {
-    let mut buf = String::new();
-    go(&mut buf, map, "\ncrate", map.root);
-    return buf.trim().to_string();
-
-    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
-        *buf += path;
-        *buf += "\n";
-
-        let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
-        entries.sort_by_key(|(name, _)| name.clone());
-
-        for (name, def) in entries {
-            *buf += &format!("{}:", name);
-
-            if def.types.is_some() {
-                *buf += " t";
-            }
-            if def.values.is_some() {
-                *buf += " v";
-            }
-            if def.macros.is_some() {
-                *buf += " m";
-            }
-            if def.is_none() {
-                *buf += " _";
-            }
-
-            *buf += "\n";
-        }
-
-        for (name, child) in map.modules[module].children.iter() {
-            let path = path.to_string() + &format!("::{}", name);
-            go(buf, map, &path, *child);
-        }
-    }
-}
-
 #[test]
 fn crate_def_map_smoke_test() {
     let map = def_map(
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index ab290e2c9..246032c13 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -16,13 +16,13 @@ use ra_syntax::ast;
 
 use crate::{type_ref::TypeRef, InFile};
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ModPath {
     pub kind: PathKind,
     pub segments: Vec<Name>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum PathKind {
     Plain,
     /// `self::` is `Super(0)`
@@ -34,6 +34,14 @@ pub enum PathKind {
     DollarCrate(CrateId),
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ImportAlias {
+    /// Unnamed alias, as in `use Foo as _;`
+    Underscore,
+    /// Named alias
+    Alias(Name),
+}
+
 impl ModPath {
     pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
         lower::lower_path(path, hygiene).map(|it| it.mod_path)
@@ -57,7 +65,7 @@ impl ModPath {
     pub(crate) fn expand_use_item(
         item_src: InFile<ast::UseItem>,
         hygiene: &Hygiene,
-        mut cb: impl FnMut(ModPath, &ast::UseTree, /* is_glob */ bool, Option<Name>),
+        mut cb: impl FnMut(ModPath, &ast::UseTree, /* is_glob */ bool, Option<ImportAlias>),
     ) {
         if let Some(tree) = item_src.value.use_tree() {
             lower::lower_use_tree(None, tree, hygiene, &mut cb);
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 531878174..d2bc9d193 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -4,20 +4,17 @@
 use std::iter;
 
 use either::Either;
-use hir_expand::{
-    hygiene::Hygiene,
-    name::{AsName, Name},
-};
+use hir_expand::{hygiene::Hygiene, name::AsName};
 use ra_syntax::ast::{self, NameOwner};
 use test_utils::tested_by;
 
-use crate::path::{ModPath, PathKind};
+use crate::path::{ImportAlias, ModPath, PathKind};
 
 pub(crate) fn lower_use_tree(
     prefix: Option<ModPath>,
     tree: ast::UseTree,
     hygiene: &Hygiene,
-    cb: &mut dyn FnMut(ModPath, &ast::UseTree, bool, Option<Name>),
+    cb: &mut dyn FnMut(ModPath, &ast::UseTree, bool, Option<ImportAlias>),
 ) {
     if let Some(use_tree_list) = tree.use_tree_list() {
         let prefix = match tree.path() {
@@ -34,7 +31,11 @@ pub(crate) fn lower_use_tree(
             lower_use_tree(prefix.clone(), child_tree, hygiene, cb);
         }
     } else {
-        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
+        let alias = tree.alias().map(|a| {
+            a.name()
+                .map(|it| it.as_name())
+                .map_or(ImportAlias::Underscore, |a| ImportAlias::Alias(a))
+        });
         let is_glob = tree.has_star();
         if let Some(ast_path) = tree.path() {
             // Handle self in a path.
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index f7bac5801..05cf4646a 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -490,10 +490,12 @@ impl Scope {
             }
             Scope::GenericParams { params, def } => {
                 for (local_id, param) in params.types.iter() {
-                    f(
-                        param.name.clone(),
-                        ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
-                    )
+                    if let Some(name) = &param.name {
+                        f(
+                            name.clone(),
+                            ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
+                        )
+                    }
                 }
             }
             Scope::ImplBlockScope(i) => {
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index 5f10e9a88..102fdb13d 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -124,6 +124,48 @@ impl TypeRef {
     pub(crate) fn unit() -> TypeRef {
         TypeRef::Tuple(Vec::new())
     }
+
+    pub fn walk(&self, f: &mut impl FnMut(&TypeRef)) {
+        go(self, f);
+
+        fn go(type_ref: &TypeRef, f: &mut impl FnMut(&TypeRef)) {
+            f(type_ref);
+            match type_ref {
+                TypeRef::Fn(types) | TypeRef::Tuple(types) => types.iter().for_each(|t| go(t, f)),
+                TypeRef::RawPtr(type_ref, _)
+                | TypeRef::Reference(type_ref, _)
+                | TypeRef::Array(type_ref)
+                | TypeRef::Slice(type_ref) => go(&type_ref, f),
+                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
+                    for bound in bounds {
+                        match bound {
+                            TypeBound::Path(path) => go_path(path, f),
+                            TypeBound::Error => (),
+                        }
+                    }
+                }
+                TypeRef::Path(path) => go_path(path, f),
+                TypeRef::Never | TypeRef::Placeholder | TypeRef::Error => {}
+            };
+        }
+
+        fn go_path(path: &Path, f: &mut impl FnMut(&TypeRef)) {
+            if let Some(type_ref) = path.type_anchor() {
+                go(type_ref, f);
+            }
+            for segment in path.segments().iter() {
+                if let Some(args_and_bindings) = segment.args_and_bindings {
+                    for arg in &args_and_bindings.args {
+                        let crate::path::GenericArg::Type(type_ref) = arg;
+                        go(type_ref, f);
+                    }
+                    for (_, type_ref) in &args_and_bindings.bindings {
+                        go(type_ref, f);
+                    }
+                }
+            }
+        }
+    }
 }
 
 pub(crate) fn type_bounds_from_ast(type_bounds_opt: Option<ast::TypeBoundList>) -> Vec<TypeBound> {
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index b3fa1efba..b2e10f445 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -141,6 +141,8 @@ pub mod known {
         macro_rules,
         // Components of known path (value or mod name)
         std,
+        core,
+        alloc,
         iter,
         ops,
         future,
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 60793db44..f5484bf70 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -21,11 +21,11 @@ ra_prof = { path = "../ra_prof" }
 ra_syntax = { path = "../ra_syntax" }
 test_utils = { path = "../test_utils" }
 
-chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
-chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
+chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
 
 lalrpop-intern = "0.15.1"
 
 [dev-dependencies]
-insta = "0.12.0"
+insta = "0.13.0"
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index eb521c7a0..e9bfcfa17 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -3,17 +3,18 @@
 use std::sync::Arc;
 
 use hir_def::{
-    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, VariantId,
+    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, TypeParamId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
-use ra_db::{salsa, CrateId};
+use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 
 use crate::{
     method_resolution::CrateImplBlocks,
     traits::{chalk, AssocTyValue, Impl},
-    CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, TraitRef, Ty, TyDefId, TypeCtor,
-    ValueTyDefId,
+    Binders, CallableDef, GenericPredicate, InferenceResult, PolyFnSig, Substs, TraitRef, Ty,
+    TyDefId, TypeCtor, ValueTyDefId,
 };
 
 #[salsa::query_group(HirDatabaseStorage)]
@@ -27,34 +28,33 @@ pub trait HirDatabase: DefDatabase {
 
     #[salsa::invoke(crate::lower::ty_query)]
     #[salsa::cycle(crate::lower::ty_recover)]
-    fn ty(&self, def: TyDefId) -> Ty;
+    fn ty(&self, def: TyDefId) -> Binders<Ty>;
 
     #[salsa::invoke(crate::lower::value_ty_query)]
-    fn value_ty(&self, def: ValueTyDefId) -> Ty;
+    fn value_ty(&self, def: ValueTyDefId) -> Binders<Ty>;
 
     #[salsa::invoke(crate::lower::impl_self_ty_query)]
     #[salsa::cycle(crate::lower::impl_self_ty_recover)]
-    fn impl_self_ty(&self, def: ImplId) -> Ty;
+    fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>;
 
     #[salsa::invoke(crate::lower::impl_trait_query)]
-    fn impl_trait(&self, def: ImplId) -> Option<TraitRef>;
+    fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
 
     #[salsa::invoke(crate::lower::field_types_query)]
-    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Ty>>;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>>;
 
     #[salsa::invoke(crate::callable_item_sig)]
-    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
+    fn callable_item_signature(&self, def: CallableDef) -> PolyFnSig;
 
     #[salsa::invoke(crate::lower::generic_predicates_for_param_query)]
     #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]
     fn generic_predicates_for_param(
         &self,
-        def: GenericDefId,
-        param_idx: u32,
-    ) -> Arc<[GenericPredicate]>;
+        param_id: TypeParamId,
+    ) -> Arc<[Binders<GenericPredicate>]>;
 
     #[salsa::invoke(crate::lower::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDefId) -> Arc<[GenericPredicate]>;
+    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
 
     #[salsa::invoke(crate::lower::generic_defaults_query)]
     fn generic_defaults(&self, def: GenericDefId) -> Substs;
@@ -77,6 +77,8 @@ pub trait HirDatabase: DefDatabase {
     #[salsa::interned]
     fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::TypeCtorId;
     #[salsa::interned]
+    fn intern_type_param_id(&self, param_id: TypeParamId) -> GlobalTypeParamId;
+    #[salsa::interned]
     fn intern_chalk_impl(&self, impl_: Impl) -> crate::traits::GlobalImplId;
     #[salsa::interned]
     fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> crate::traits::AssocTyValueId;
@@ -117,3 +119,7 @@ fn infer(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
 fn hir_database_is_object_safe() {
     fn _assert_object_safe(_: &dyn HirDatabase) {}
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlobalTypeParamId(salsa::InternId);
+impl_intern_key!(GlobalTypeParamId);
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index e2eda3134..a9d958c8b 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -34,7 +34,6 @@ use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
 use ra_prof::profile;
 use ra_syntax::SmolStr;
-use test_utils::tested_by;
 
 use super::{
     primitive::{FloatTy, IntTy},
@@ -42,7 +41,9 @@ use super::{
     ApplicationTy, GenericPredicate, InEnvironment, ProjectionTy, Substs, TraitEnvironment,
     TraitRef, Ty, TypeCtor, TypeWalk, Uncertain,
 };
-use crate::{db::HirDatabase, infer::diagnostics::InferenceDiagnostic};
+use crate::{
+    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+};
 
 pub(crate) use unify::unify;
 
@@ -271,38 +272,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.result.diagnostics.push(diagnostic);
     }
 
-    fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
-        let ty = Ty::from_hir(
-            self.db,
-            // FIXME use right resolver for block
-            &self.resolver,
-            type_ref,
-        );
+    fn make_ty_with_mode(
+        &mut self,
+        type_ref: &TypeRef,
+        impl_trait_mode: ImplTraitLoweringMode,
+    ) -> Ty {
+        // FIXME use right resolver for block
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
+            .with_impl_trait_mode(impl_trait_mode);
+        let ty = Ty::from_hir(&ctx, type_ref);
         let ty = self.insert_type_vars(ty);
         self.normalize_associated_types_in(ty)
     }
 
-    /// Replaces `impl Trait` in `ty` by type variables and obligations for
-    /// those variables. This is done for function arguments when calling a
-    /// function, and for return types when inside the function body, i.e. in
-    /// the cases where the `impl Trait` is 'transparent'. In other cases, `impl
-    /// Trait` is represented by `Ty::Opaque`.
-    fn insert_vars_for_impl_trait(&mut self, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty {
-            Ty::Opaque(preds) => {
-                tested_by!(insert_vars_for_impl_trait);
-                let var = self.table.new_type_var();
-                let var_subst = Substs::builder(1).push(var.clone()).build();
-                self.obligations.extend(
-                    preds
-                        .iter()
-                        .map(|pred| pred.clone().subst_bound_vars(&var_subst))
-                        .filter_map(Obligation::from_predicate),
-                );
-                var
-            }
-            _ => ty,
-        })
+    fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
+        self.make_ty_with_mode(type_ref, ImplTraitLoweringMode::Disallowed)
     }
 
     /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
@@ -446,19 +430,20 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             None => return (Ty::Unknown, None),
         };
         let resolver = &self.resolver;
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
         // FIXME: this should resolve assoc items as well, see this example:
         // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521
         match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) {
             Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {
-                let substs = Ty::substs_from_path(self.db, resolver, path, strukt.into());
+                let substs = Ty::substs_from_path(&ctx, path, strukt.into());
                 let ty = self.db.ty(strukt.into());
-                let ty = self.insert_type_vars(ty.apply_substs(substs));
+                let ty = self.insert_type_vars(ty.subst(&substs));
                 (ty, Some(strukt.into()))
             }
             Some(TypeNs::EnumVariantId(var)) => {
-                let substs = Ty::substs_from_path(self.db, resolver, path, var.into());
+                let substs = Ty::substs_from_path(&ctx, path, var.into());
                 let ty = self.db.ty(var.parent.into());
-                let ty = self.insert_type_vars(ty.apply_substs(substs));
+                let ty = self.insert_type_vars(ty.subst(&substs));
                 (ty, Some(var.into()))
             }
             Some(_) | None => (Ty::Unknown, None),
@@ -471,13 +456,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
     fn collect_fn(&mut self, data: &FunctionData) {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
-        for (type_ref, pat) in data.params.iter().zip(body.params.iter()) {
-            let ty = self.make_ty(type_ref);
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
+            .with_impl_trait_mode(ImplTraitLoweringMode::Param);
+        let param_tys =
+            data.params.iter().map(|type_ref| Ty::from_hir(&ctx, type_ref)).collect::<Vec<_>>();
+        for (ty, pat) in param_tys.into_iter().zip(body.params.iter()) {
+            let ty = self.insert_type_vars(ty);
+            let ty = self.normalize_associated_types_in(ty);
 
             self.infer_pat(*pat, &ty, BindingMode::default());
         }
-        let return_ty = self.make_ty(&data.ret_type);
-        self.return_ty = self.insert_vars_for_impl_trait(return_ty);
+        let return_ty = self.make_ty_with_mode(&data.ret_type, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
+        self.return_ty = return_ty;
     }
 
     fn infer_body(&mut self) {
diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 83c0c2c3f..f68a1439f 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -57,8 +57,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let trait_ref = db.impl_trait(impl_id)?;
 
                 // `CoerseUnsized` has one generic parameter for the target type.
-                let cur_from_ty = trait_ref.substs.0.get(0)?;
-                let cur_to_ty = trait_ref.substs.0.get(1)?;
+                let cur_from_ty = trait_ref.value.substs.0.get(0)?;
+                let cur_to_ty = trait_ref.value.substs.0.get(1)?;
 
                 match (&cur_from_ty, cur_to_ty) {
                     (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => {
@@ -66,9 +66,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         // This works for smart-pointer-like coercion, which covers all impls from std.
                         st1.iter().zip(st2.iter()).enumerate().find_map(|(i, (ty1, ty2))| {
                             match (ty1, ty2) {
-                                (Ty::Param { idx: p1, .. }, Ty::Param { idx: p2, .. })
-                                    if p1 != p2 =>
-                                {
+                                (Ty::Bound(idx1), Ty::Bound(idx2)) if idx1 != idx2 => {
                                     Some(((*ctor1, *ctor2), i))
                                 }
                                 _ => None,
@@ -256,8 +254,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let unsize_generic_index = {
                     let mut index = None;
                     let mut multiple_param = false;
-                    field_tys[last_field_id].walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } => {
+                    field_tys[last_field_id].value.walk(&mut |ty| match ty {
+                        &Ty::Bound(idx) => {
                             if index.is_none() {
                                 index = Some(idx);
                             } else if Some(idx) != index {
@@ -276,10 +274,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 // Check other fields do not involve it.
                 let mut multiple_used = false;
                 fields.for_each(|(field_id, _data)| {
-                    field_tys[field_id].walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
-                            multiple_used = true
-                        }
+                    field_tys[field_id].value.walk(&mut |ty| match ty {
+                        &Ty::Bound(idx) if idx == unsize_generic_index => multiple_used = true,
                         _ => {}
                     })
                 });
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 31259a01d..3c9c02d03 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -10,7 +10,7 @@ use hir_def::{
     resolver::resolver_for_expr,
     AdtId, AssocContainerId, Lookup, StructFieldId,
 };
-use hir_expand::name::{name, Name};
+use hir_expand::name::Name;
 use ra_syntax::ast::RangeOp;
 
 use crate::{
@@ -19,8 +19,8 @@ use crate::{
     method_resolution, op,
     traits::InEnvironment,
     utils::{generics, variant_data, Generics},
-    ApplicationTy, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef, Ty,
-    TypeCtor, TypeWalk, Uncertain,
+    ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef,
+    Ty, TypeCtor, Uncertain,
 };
 
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
@@ -236,8 +236,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         self.result.record_field_resolutions.insert(field.expr, field_def);
                     }
                     let field_ty = field_def
-                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone())
-                        .subst(&substs);
+                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone().subst(&substs));
                     self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                 }
                 if let Some(expr) = spread {
@@ -588,10 +587,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.write_method_resolution(tgt_expr, func);
                 (ty, self.db.value_ty(func.into()), Some(generics(self.db, func.into())))
             }
-            None => (receiver_ty, Ty::Unknown, None),
+            None => (receiver_ty, Binders::new(0, Ty::Unknown), None),
         };
         let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
-        let method_ty = method_ty.apply_substs(substs);
+        let method_ty = method_ty.subst(&substs);
         let method_ty = self.insert_type_vars(method_ty);
         self.register_obligations_for_call(&method_ty);
         let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
@@ -635,7 +634,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     continue;
                 }
 
-                let param_ty = self.insert_vars_for_impl_trait(param_ty);
                 let param_ty = self.normalize_associated_types_in(param_ty);
                 self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
             }
@@ -648,13 +646,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         generic_args: Option<&GenericArgs>,
         receiver_ty: &Ty,
     ) -> Substs {
-        let (total_len, _parent_len, child_len) =
-            def_generics.as_ref().map_or((0, 0, 0), |g| g.len_split());
+        let (parent_params, self_params, type_params, impl_trait_params) =
+            def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
+        assert_eq!(self_params, 0); // method shouldn't have another Self param
+        let total_len = parent_params + type_params + impl_trait_params;
         let mut substs = Vec::with_capacity(total_len);
         // Parent arguments are unknown, except for the receiver type
         if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
             for (_id, param) in parent_generics {
-                if param.name == name![Self] {
+                if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
                     substs.push(receiver_ty.clone());
                 } else {
                     substs.push(Ty::Unknown);
@@ -664,7 +664,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         // handle provided type arguments
         if let Some(generic_args) = generic_args {
             // if args are provided, it should be all of them, but we can't rely on that
-            for arg in generic_args.args.iter().take(child_len) {
+            for arg in generic_args.args.iter().take(type_params) {
                 match arg {
                     GenericArg::Type(type_ref) => {
                         let ty = self.make_ty(type_ref);
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index a14662884..e7283f24c 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -12,7 +12,7 @@ use hir_expand::name::Name;
 use test_utils::tested_by;
 
 use super::{BindingMode, InferenceContext};
-use crate::{db::HirDatabase, utils::variant_data, Substs, Ty, TypeCtor, TypeWalk};
+use crate::{db::HirDatabase, utils::variant_data, Substs, Ty, TypeCtor};
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     fn infer_tuple_struct_pat(
@@ -34,8 +34,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             let expected_ty = var_data
                 .as_ref()
                 .and_then(|d| d.field(&Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field_tys[field].clone())
-                .subst(&substs);
+                .map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
             let expected_ty = self.normalize_associated_types_in(expected_ty);
             self.infer_pat(subpat, &expected_ty, default_bm);
         }
@@ -65,7 +64,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         for subpat in subpats {
             let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
             let expected_ty =
-                matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone()).subst(&substs);
+                matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
             let expected_ty = self.normalize_associated_types_in(expected_ty);
             self.infer_pat(subpat.pat, &expected_ty, default_bm);
         }
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 2c1d4831d..686ce7a21 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -9,9 +9,9 @@ use hir_def::{
 };
 use hir_expand::name::Name;
 
-use crate::{db::HirDatabase, method_resolution, Substs, Ty, TypeWalk, ValueTyDefId};
+use crate::{db::HirDatabase, method_resolution, Substs, Ty, ValueTyDefId};
 
-use super::{ExprOrPatId, InferenceContext, TraitEnvironment, TraitRef};
+use super::{ExprOrPatId, InferenceContext, TraitRef};
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     pub(super) fn infer_path(
@@ -39,7 +39,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             let ty = self.make_ty(type_ref);
             let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
-            let ty = Ty::from_type_relative_path(self.db, resolver, ty, remaining_segments_for_ty);
+            let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver);
+            let ty = Ty::from_type_relative_path(&ctx, ty, remaining_segments_for_ty);
             self.resolve_ty_assoc_item(
                 ty,
                 &path.segments().last().expect("path had at least one segment").name,
@@ -69,12 +70,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             ValueNs::EnumVariantId(it) => it.into(),
         };
 
-        let mut ty = self.db.value_ty(typable);
-        if let Some(self_subst) = self_subst {
-            ty = ty.subst(&self_subst);
-        }
-        let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
-        let ty = ty.subst(&substs);
+        let ty = self.db.value_ty(typable);
+        // self_subst is just for the parent
+        let parent_substs = self_subst.unwrap_or_else(Substs::empty);
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
+        let substs = Ty::substs_from_path(&ctx, path, typable);
+        let full_substs = Substs::builder(substs.len())
+            .use_parent_substs(&parent_substs)
+            .fill(substs.0[parent_substs.len()..].iter().cloned())
+            .build();
+        let ty = ty.subst(&full_substs);
         Some(ty)
     }
 
@@ -98,13 +103,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             (TypeNs::TraitId(trait_), true) => {
                 let segment =
                     remaining_segments.last().expect("there should be at least one segment here");
-                let trait_ref = TraitRef::from_resolved_path(
-                    self.db,
-                    &self.resolver,
-                    trait_.into(),
-                    resolved_segment,
-                    None,
-                );
+                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
+                let trait_ref =
+                    TraitRef::from_resolved_path(&ctx, trait_.into(), resolved_segment, None);
                 self.resolve_trait_assoc_item(trait_ref, segment, id)
             }
             (def, _) => {
@@ -114,9 +115,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 // as Iterator>::Item::default`)
                 let remaining_segments_for_ty =
                     remaining_segments.take(remaining_segments.len() - 1);
+                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
                 let ty = Ty::from_partly_resolved_hir_path(
-                    self.db,
-                    &self.resolver,
+                    &ctx,
                     def,
                     resolved_segment,
                     remaining_segments_for_ty,
@@ -173,13 +174,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             AssocItemId::ConstId(c) => ValueNs::ConstId(c),
             AssocItemId::TypeAliasId(_) => unreachable!(),
         };
-        let substs = Substs::build_for_def(self.db, item)
-            .use_parent_substs(&trait_ref.substs)
-            .fill_with_params()
-            .build();
 
         self.write_assoc_resolution(id, item);
-        Some((def, Some(substs)))
+        Some((def, Some(trait_ref.substs)))
     }
 
     fn resolve_ty_assoc_item(
@@ -193,14 +190,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         }
 
         let canonical_ty = self.canonicalizer().canonicalize_ty(ty.clone());
-        let env = TraitEnvironment::lower(self.db, &self.resolver);
         let krate = self.resolver.krate()?;
         let traits_in_scope = self.resolver.traits_in_scope(self.db);
 
         method_resolution::iterate_method_candidates(
             &canonical_ty.value,
             self.db,
-            env,
+            self.trait_env.clone(),
             krate,
             &traits_in_scope,
             Some(name),
@@ -219,12 +215,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             .fill(iter::repeat_with(|| self.table.new_type_var()))
                             .build();
                         let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
-                        let substs = Substs::build_for_def(self.db, item)
-                            .use_parent_substs(&impl_substs)
-                            .fill_with_params()
-                            .build();
                         self.unify(&impl_self_ty, &ty);
-                        Some(substs)
+                        Some(impl_substs)
                     }
                     AssocContainerId::TraitId(trait_) => {
                         // we're picking this method
@@ -232,15 +224,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             .push(ty.clone())
                             .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                             .build();
-                        let substs = Substs::build_for_def(self.db, item)
-                            .use_parent_substs(&trait_substs)
-                            .fill_with_params()
-                            .build();
                         self.obligations.push(super::Obligation::Trait(TraitRef {
                             trait_,
-                            substs: trait_substs,
+                            substs: trait_substs.clone(),
                         }));
-                        Some(substs)
+                        Some(trait_substs)
                     }
                     AssocContainerId::ContainerId(_) => None,
                 };
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 908e4862d..c5fe18c85 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -44,8 +44,8 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 
 use hir_def::{
-    expr::ExprId, type_ref::Mutability, AdtId, AssocContainerId, DefWithBodyId, GenericDefId,
-    HasModule, Lookup, TraitId, TypeAliasId,
+    expr::ExprId, generics::TypeParamProvenance, type_ref::Mutability, AdtId, AssocContainerId,
+    DefWithBodyId, GenericDefId, HasModule, Lookup, TraitId, TypeAliasId, TypeParamId,
 };
 use hir_expand::name::Name;
 use ra_db::{impl_intern_key, salsa, CrateId};
@@ -60,7 +60,9 @@ use display::{HirDisplay, HirFormatter};
 pub use autoderef::autoderef;
 pub use infer::{do_infer_query, InferTy, InferenceResult};
 pub use lower::CallableDef;
-pub use lower::{callable_item_sig, TyDefId, ValueTyDefId};
+pub use lower::{
+    callable_item_sig, ImplTraitLoweringMode, TyDefId, TyLoweringContext, ValueTyDefId,
+};
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
 /// A type constructor or type name: this might be something like the primitive
@@ -285,22 +287,20 @@ pub enum Ty {
     /// trait and all its parameters are fully known.
     Projection(ProjectionTy),
 
-    /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
-    Param {
-        /// The index of the parameter (starting with parameters from the
-        /// surrounding impl, then the current function).
-        idx: u32,
-        /// The name of the parameter, for displaying.
-        // FIXME get rid of this
-        name: Name,
-    },
-
-    /// A bound type variable. Used during trait resolution to represent Chalk
-    /// variables, and in `Dyn` and `Opaque` bounds to represent the `Self` type.
+    /// A placeholder for a type parameter; for example, `T` in `fn f<T>(x: T)
+    /// {}` when we're type-checking the body of that function. In this
+    /// situation, we know this stands for *some* type, but don't know the exact
+    /// type.
+    Param(TypeParamId),
+
+    /// A bound type variable. This is used in various places: when representing
+    /// some polymorphic type like the type of function `fn f<T>`, the type
+    /// parameters get turned into variables; during trait resolution, inference
+    /// variables get turned into bound variables and back; and in `Dyn` the
+    /// `Self` type is represented with a bound variable as well.
     Bound(u32),
 
-    /// A type variable used during type checking. Not to be confused with a
-    /// type parameter.
+    /// A type variable used during type checking.
     Infer(InferTy),
 
     /// A trait object (`dyn Trait` or bare `Trait` in pre-2018 Rust).
@@ -364,15 +364,19 @@ impl Substs {
     }
 
     /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
-    pub(crate) fn identity(generic_params: &Generics) -> Substs {
-        Substs(
-            generic_params.iter().map(|(idx, p)| Ty::Param { idx, name: p.name.clone() }).collect(),
-        )
+    pub(crate) fn type_params_for_generics(generic_params: &Generics) -> Substs {
+        Substs(generic_params.iter().map(|(id, _)| Ty::Param(id)).collect())
+    }
+
+    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
+    pub fn type_params(db: &impl HirDatabase, def: impl Into<GenericDefId>) -> Substs {
+        let params = generics(db, def.into());
+        Substs::type_params_for_generics(&params)
     }
 
     /// Return Substs that replace each parameter by a bound variable.
     pub(crate) fn bound_vars(generic_params: &Generics) -> Substs {
-        Substs(generic_params.iter().map(|(idx, _p)| Ty::Bound(idx)).collect())
+        Substs(generic_params.iter().enumerate().map(|(idx, _)| Ty::Bound(idx as u32)).collect())
     }
 
     pub fn build_for_def(db: &impl HirDatabase, def: impl Into<GenericDefId>) -> SubstsBuilder {
@@ -420,11 +424,6 @@ impl SubstsBuilder {
         self.fill((starting_from..).map(Ty::Bound))
     }
 
-    pub fn fill_with_params(self) -> Self {
-        let start = self.vec.len() as u32;
-        self.fill((start..).map(|idx| Ty::Param { idx, name: Name::missing() }))
-    }
-
     pub fn fill_with_unknown(self) -> Self {
         self.fill(iter::repeat(Ty::Unknown))
     }
@@ -451,6 +450,32 @@ impl Deref for Substs {
     }
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Binders<T> {
+    pub num_binders: usize,
+    pub value: T,
+}
+
+impl<T> Binders<T> {
+    pub fn new(num_binders: usize, value: T) -> Self {
+        Self { num_binders, value }
+    }
+}
+
+impl<T: TypeWalk> Binders<T> {
+    /// Substitutes all variables.
+    pub fn subst(self, subst: &Substs) -> T {
+        assert_eq!(subst.len(), self.num_binders);
+        self.value.subst_bound_vars(subst)
+    }
+
+    /// Substitutes just a prefix of the variables (shifting the rest).
+    pub fn subst_prefix(self, subst: &Substs) -> Binders<T> {
+        assert!(subst.len() < self.num_binders);
+        Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst))
+    }
+}
+
 /// A trait with type parameters. This includes the `Self`, so this represents a concrete type implementing the trait.
 /// Name to be bikeshedded: TraitBound? TraitImplements?
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -551,6 +576,9 @@ pub struct FnSig {
     params_and_return: Arc<[Ty]>,
 }
 
+/// A polymorphic function signature.
+pub type PolyFnSig = Binders<FnSig>;
+
 impl FnSig {
     pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
         params.push(ret);
@@ -730,22 +758,7 @@ pub trait TypeWalk {
         self
     }
 
-    /// Replaces type parameters in this type using the given `Substs`. (So e.g.
-    /// if `self` is `&[T]`, where type parameter T has index 0, and the
-    /// `Substs` contain `u32` at index 0, we'll have `&[u32]` afterwards.)
-    fn subst(self, substs: &Substs) -> Self
-    where
-        Self: Sized,
-    {
-        self.fold(&mut |ty| match ty {
-            Ty::Param { idx, name } => {
-                substs.get(idx as usize).cloned().unwrap_or(Ty::Param { idx, name })
-            }
-            ty => ty,
-        })
-    }
-
-    /// Substitutes `Ty::Bound` vars (as opposed to type parameters).
+    /// Substitutes `Ty::Bound` vars with the given substitution.
     fn subst_bound_vars(mut self, substs: &Substs) -> Self
     where
         Self: Sized,
@@ -755,6 +768,9 @@ pub trait TypeWalk {
                 &mut Ty::Bound(idx) => {
                     if idx as usize >= binders && (idx as usize - binders) < substs.len() {
                         *ty = substs.0[idx as usize - binders].clone();
+                    } else if idx as usize >= binders + substs.len() {
+                        // shift free binders
+                        *ty = Ty::Bound(idx - substs.len() as u32);
                     }
                 }
                 _ => {}
@@ -847,7 +863,7 @@ impl HirDisplay for ApplicationTy {
             }
             TypeCtor::Array => {
                 let t = self.parameters.as_single();
-                write!(f, "[{};_]", t.display(f.db))?;
+                write!(f, "[{}; _]", t.display(f.db))?;
             }
             TypeCtor::RawPtr(m) => {
                 let t = self.parameters.as_single();
@@ -880,7 +896,7 @@ impl HirDisplay for ApplicationTy {
                 write!(f, ") -> {}", sig.ret().display(f.db))?;
             }
             TypeCtor::FnDef(def) => {
-                let sig = f.db.callable_item_signature(def);
+                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
                 let name = match def {
                     CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
                     CallableDef::StructId(s) => f.db.struct_data(s).name.clone(),
@@ -896,9 +912,16 @@ impl HirDisplay for ApplicationTy {
                     }
                 }
                 if self.parameters.len() > 0 {
-                    write!(f, "<")?;
-                    f.write_joined(&*self.parameters.0, ", ")?;
-                    write!(f, ">")?;
+                    let generics = generics(f.db, def.into());
+                    let (parent_params, self_param, type_params, _impl_trait_params) =
+                        generics.provenance_split();
+                    let total_len = parent_params + self_param + type_params;
+                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
+                    if total_len > 0 {
+                        write!(f, "<")?;
+                        f.write_joined(&self.parameters.0[..total_len], ", ")?;
+                        write!(f, ">")?;
+                    }
                 }
                 write!(f, "(")?;
                 f.write_joined(sig.params(), ", ")?;
@@ -1009,7 +1032,24 @@ impl HirDisplay for Ty {
         match self {
             Ty::Apply(a_ty) => a_ty.hir_fmt(f)?,
             Ty::Projection(p_ty) => p_ty.hir_fmt(f)?,
-            Ty::Param { name, .. } => write!(f, "{}", name)?,
+            Ty::Param(id) => {
+                let generics = generics(f.db, id.parent);
+                let param_data = &generics.params.types[id.local_id];
+                match param_data.provenance {
+                    TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
+                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
+                    }
+                    TypeParamProvenance::ArgumentImplTrait => {
+                        write!(f, "impl ")?;
+                        let bounds = f.db.generic_predicates_for_param(*id);
+                        let substs = Substs::type_params_for_generics(&generics);
+                        write_bounds_like_dyn_trait(
+                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
+                            f,
+                        )?;
+                    }
+                }
+            }
             Ty::Bound(idx) => write!(f, "?{}", idx)?,
             Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
                 match self {
@@ -1017,66 +1057,7 @@ impl HirDisplay for Ty {
                     Ty::Opaque(_) => write!(f, "impl ")?,
                     _ => unreachable!(),
                 };
-                // Note: This code is written to produce nice results (i.e.
-                // corresponding to surface Rust) for types that can occur in
-                // actual Rust. It will have weird results if the predicates
-                // aren't as expected (i.e. self types = $0, projection
-                // predicates for a certain trait come after the Implemented
-                // predicate for that trait).
-                let mut first = true;
-                let mut angle_open = false;
-                for p in predicates.iter() {
-                    match p {
-                        GenericPredicate::Implemented(trait_ref) => {
-                            if angle_open {
-                                write!(f, ">")?;
-                            }
-                            if !first {
-                                write!(f, " + ")?;
-                            }
-                            // We assume that the self type is $0 (i.e. the
-                            // existential) here, which is the only thing that's
-                            // possible in actual Rust, and hence don't print it
-                            write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
-                            if trait_ref.substs.len() > 1 {
-                                write!(f, "<")?;
-                                f.write_joined(&trait_ref.substs[1..], ", ")?;
-                                // there might be assoc type bindings, so we leave the angle brackets open
-                                angle_open = true;
-                            }
-                        }
-                        GenericPredicate::Projection(projection_pred) => {
-                            // in types in actual Rust, these will always come
-                            // after the corresponding Implemented predicate
-                            if angle_open {
-                                write!(f, ", ")?;
-                            } else {
-                                write!(f, "<")?;
-                                angle_open = true;
-                            }
-                            let name =
-                                f.db.type_alias_data(projection_pred.projection_ty.associated_ty)
-                                    .name
-                                    .clone();
-                            write!(f, "{} = ", name)?;
-                            projection_pred.ty.hir_fmt(f)?;
-                        }
-                        GenericPredicate::Error => {
-                            if angle_open {
-                                // impl Trait<X, {error}>
-                                write!(f, ", ")?;
-                            } else if !first {
-                                // impl Trait + {error}
-                                write!(f, " + ")?;
-                            }
-                            p.hir_fmt(f)?;
-                        }
-                    }
-                    first = false;
-                }
-                if angle_open {
-                    write!(f, ">")?;
-                }
+                write_bounds_like_dyn_trait(&predicates, f)?;
             }
             Ty::Unknown => write!(f, "{{unknown}}")?,
             Ty::Infer(..) => write!(f, "_")?,
@@ -1085,6 +1066,71 @@ impl HirDisplay for Ty {
     }
 }
 
+fn write_bounds_like_dyn_trait(
+    predicates: &[GenericPredicate],
+    f: &mut HirFormatter<impl HirDatabase>,
+) -> fmt::Result {
+    // Note: This code is written to produce nice results (i.e.
+    // corresponding to surface Rust) for types that can occur in
+    // actual Rust. It will have weird results if the predicates
+    // aren't as expected (i.e. self types = $0, projection
+    // predicates for a certain trait come after the Implemented
+    // predicate for that trait).
+    let mut first = true;
+    let mut angle_open = false;
+    for p in predicates.iter() {
+        match p {
+            GenericPredicate::Implemented(trait_ref) => {
+                if angle_open {
+                    write!(f, ">")?;
+                }
+                if !first {
+                    write!(f, " + ")?;
+                }
+                // We assume that the self type is $0 (i.e. the
+                // existential) here, which is the only thing that's
+                // possible in actual Rust, and hence don't print it
+                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
+                if trait_ref.substs.len() > 1 {
+                    write!(f, "<")?;
+                    f.write_joined(&trait_ref.substs[1..], ", ")?;
+                    // there might be assoc type bindings, so we leave the angle brackets open
+                    angle_open = true;
+                }
+            }
+            GenericPredicate::Projection(projection_pred) => {
+                // in types in actual Rust, these will always come
+                // after the corresponding Implemented predicate
+                if angle_open {
+                    write!(f, ", ")?;
+                } else {
+                    write!(f, "<")?;
+                    angle_open = true;
+                }
+                let name =
+                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name.clone();
+                write!(f, "{} = ", name)?;
+                projection_pred.ty.hir_fmt(f)?;
+            }
+            GenericPredicate::Error => {
+                if angle_open {
+                    // impl Trait<X, {error}>
+                    write!(f, ", ")?;
+                } else if !first {
+                    // impl Trait + {error}
+                    write!(f, " + ")?;
+                }
+                p.hir_fmt(f)?;
+            }
+        }
+        first = false;
+    }
+    if angle_open {
+        write!(f, ">")?;
+    }
+    Ok(())
+}
+
 impl TraitRef {
     fn hir_fmt_ext(&self, f: &mut HirFormatter<impl HirDatabase>, use_as: bool) -> fmt::Result {
         if f.should_truncate() {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 2c2ecee9c..c68c5852b 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -10,12 +10,13 @@ use std::sync::Arc;
 
 use hir_def::{
     builtin_type::BuiltinType,
-    generics::WherePredicate,
+    generics::{TypeParamProvenance, WherePredicate, WherePredicateTarget},
     path::{GenericArg, Path, PathSegment, PathSegments},
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{TypeBound, TypeRef},
     AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule, ImplId,
-    LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
+    LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
 use ra_db::CrateId;
@@ -27,63 +28,158 @@ use crate::{
         all_super_traits, associated_type_by_name_including_super_traits, generics, make_mut_slice,
         variant_data,
     },
-    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef,
-    Ty, TypeCtor, TypeWalk,
+    Binders, FnSig, GenericPredicate, PolyFnSig, ProjectionPredicate, ProjectionTy, Substs,
+    TraitEnvironment, TraitRef, Ty, TypeCtor,
 };
 
+#[derive(Debug)]
+pub struct TyLoweringContext<'a, DB: HirDatabase> {
+    pub db: &'a DB,
+    pub resolver: &'a Resolver,
+    /// Note: Conceptually, it's thinkable that we could be in a location where
+    /// some type params should be represented as placeholders, and others
+    /// should be converted to variables. I think in practice, this isn't
+    /// possible currently, so this should be fine for now.
+    pub type_param_mode: TypeParamLoweringMode,
+    pub impl_trait_mode: ImplTraitLoweringMode,
+    pub impl_trait_counter: std::cell::Cell<u16>,
+}
+
+impl<'a, DB: HirDatabase> TyLoweringContext<'a, DB> {
+    pub fn new(db: &'a DB, resolver: &'a Resolver) -> Self {
+        let impl_trait_counter = std::cell::Cell::new(0);
+        let impl_trait_mode = ImplTraitLoweringMode::Disallowed;
+        let type_param_mode = TypeParamLoweringMode::Placeholder;
+        Self { db, resolver, impl_trait_mode, impl_trait_counter, type_param_mode }
+    }
+
+    pub fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {
+        Self { impl_trait_mode, ..self }
+    }
+
+    pub fn with_type_param_mode(self, type_param_mode: TypeParamLoweringMode) -> Self {
+        Self { type_param_mode, ..self }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ImplTraitLoweringMode {
+    /// `impl Trait` gets lowered into an opaque type that doesn't unify with
+    /// anything except itself. This is used in places where values flow 'out',
+    /// i.e. for arguments of the function we're currently checking, and return
+    /// types of functions we're calling.
+    Opaque,
+    /// `impl Trait` gets lowered into a type variable. Used for argument
+    /// position impl Trait when inside the respective function, since it allows
+    /// us to support that without Chalk.
+    Param,
+    /// `impl Trait` gets lowered into a variable that can unify with some
+    /// type. This is used in places where values flow 'in', i.e. for arguments
+    /// of functions we're calling, and the return type of the function we're
+    /// currently checking.
+    Variable,
+    /// `impl Trait` is disallowed and will be an error.
+    Disallowed,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum TypeParamLoweringMode {
+    Placeholder,
+    Variable,
+}
+
 impl Ty {
-    pub fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
+    pub fn from_hir(ctx: &TyLoweringContext<'_, impl HirDatabase>, type_ref: &TypeRef) -> Self {
         match type_ref {
             TypeRef::Never => Ty::simple(TypeCtor::Never),
             TypeRef::Tuple(inner) => {
-                let inner_tys: Arc<[Ty]> =
-                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect();
+                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect();
                 Ty::apply(
                     TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
                     Substs(inner_tys),
                 )
             }
-            TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
+            TypeRef::Path(path) => Ty::from_hir_path(ctx, path),
             TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                 Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
             }
             TypeRef::Array(inner) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                 Ty::apply_one(TypeCtor::Array, inner_ty)
             }
             TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                 Ty::apply_one(TypeCtor::Slice, inner_ty)
             }
             TypeRef::Reference(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                 Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params) => {
-                let sig = Substs(params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect());
+                let sig = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
                 Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
             }
             TypeRef::DynTrait(bounds) => {
                 let self_ty = Ty::Bound(0);
                 let predicates = bounds
                     .iter()
-                    .flat_map(|b| {
-                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
-                    })
+                    .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone()))
                     .collect();
                 Ty::Dyn(predicates)
             }
             TypeRef::ImplTrait(bounds) => {
-                let self_ty = Ty::Bound(0);
-                let predicates = bounds
-                    .iter()
-                    .flat_map(|b| {
-                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
-                    })
-                    .collect();
-                Ty::Opaque(predicates)
+                match ctx.impl_trait_mode {
+                    ImplTraitLoweringMode::Opaque => {
+                        let self_ty = Ty::Bound(0);
+                        let predicates = bounds
+                            .iter()
+                            .flat_map(|b| {
+                                GenericPredicate::from_type_bound(ctx, b, self_ty.clone())
+                            })
+                            .collect();
+                        Ty::Opaque(predicates)
+                    }
+                    ImplTraitLoweringMode::Param => {
+                        let idx = ctx.impl_trait_counter.get();
+                        ctx.impl_trait_counter.set(idx + 1);
+                        if let Some(def) = ctx.resolver.generic_def() {
+                            let generics = generics(ctx.db, def);
+                            let param = generics
+                                .iter()
+                                .filter(|(_, data)| {
+                                    data.provenance == TypeParamProvenance::ArgumentImplTrait
+                                })
+                                .nth(idx as usize)
+                                .map_or(Ty::Unknown, |(id, _)| Ty::Param(id));
+                            param
+                        } else {
+                            Ty::Unknown
+                        }
+                    }
+                    ImplTraitLoweringMode::Variable => {
+                        let idx = ctx.impl_trait_counter.get();
+                        ctx.impl_trait_counter.set(idx + 1);
+                        let (parent_params, self_params, list_params, _impl_trait_params) =
+                            if let Some(def) = ctx.resolver.generic_def() {
+                                let generics = generics(ctx.db, def);
+                                generics.provenance_split()
+                            } else {
+                                (0, 0, 0, 0)
+                            };
+                        Ty::Bound(
+                            idx as u32
+                                + parent_params as u32
+                                + self_params as u32
+                                + list_params as u32,
+                        )
+                    }
+                    ImplTraitLoweringMode::Disallowed => {
+                        // FIXME: report error
+                        Ty::Unknown
+                    }
+                }
             }
             TypeRef::Error => Ty::Unknown,
         }
@@ -93,10 +189,9 @@ impl Ty {
     /// lower the self types of the predicates since that could lead to cycles.
     /// So we just check here if the `type_ref` resolves to a generic param, and which.
     fn from_hir_only_param(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         type_ref: &TypeRef,
-    ) -> Option<u32> {
+    ) -> Option<TypeParamId> {
         let path = match type_ref {
             TypeRef::Path(path) => path,
             _ => return None,
@@ -107,29 +202,26 @@ impl Ty {
         if path.segments().len() > 1 {
             return None;
         }
-        let resolution = match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
+        let resolution = match ctx.resolver.resolve_path_in_type_ns(ctx.db, path.mod_path()) {
             Some((it, None)) => it,
             _ => return None,
         };
         if let TypeNs::GenericParam(param_id) = resolution {
-            let generics = generics(db, resolver.generic_def().expect("generics in scope"));
-            let idx = generics.param_idx(param_id);
-            Some(idx)
+            Some(param_id)
         } else {
             None
         }
     }
 
     pub(crate) fn from_type_relative_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         ty: Ty,
         remaining_segments: PathSegments<'_>,
     ) -> Ty {
         if remaining_segments.len() == 1 {
             // resolve unselected assoc types
             let segment = remaining_segments.first().unwrap();
-            Ty::select_associated_type(db, resolver, ty, segment)
+            Ty::select_associated_type(ctx, ty, segment)
         } else if remaining_segments.len() > 1 {
             // FIXME report error (ambiguous associated type)
             Ty::Unknown
@@ -139,20 +231,18 @@ impl Ty {
     }
 
     pub(crate) fn from_partly_resolved_hir_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         resolution: TypeNs,
         resolved_segment: PathSegment<'_>,
         remaining_segments: PathSegments<'_>,
     ) -> Ty {
         let ty = match resolution {
             TypeNs::TraitId(trait_) => {
-                let trait_ref =
-                    TraitRef::from_resolved_path(db, resolver, trait_, resolved_segment, None);
+                let trait_ref = TraitRef::from_resolved_path(ctx, trait_, resolved_segment, None);
                 return if remaining_segments.len() == 1 {
                     let segment = remaining_segments.first().unwrap();
                     let associated_ty = associated_type_by_name_including_super_traits(
-                        db,
+                        ctx.db,
                         trait_ref.trait_,
                         &segment.name,
                     );
@@ -177,37 +267,55 @@ impl Ty {
                 };
             }
             TypeNs::GenericParam(param_id) => {
-                let generics = generics(db, resolver.generic_def().expect("generics in scope"));
-                let idx = generics.param_idx(param_id);
-                // FIXME: maybe return name in resolution?
-                let name = generics.param_name(param_id);
-                Ty::Param { idx, name }
+                let generics =
+                    generics(ctx.db, ctx.resolver.generic_def().expect("generics in scope"));
+                match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => Ty::Param(param_id),
+                    TypeParamLoweringMode::Variable => {
+                        let idx = generics.param_idx(param_id).expect("matching generics");
+                        Ty::Bound(idx)
+                    }
+                }
             }
-            TypeNs::SelfType(impl_id) => db.impl_self_ty(impl_id).clone(),
-            TypeNs::AdtSelfType(adt) => db.ty(adt.into()),
-
-            TypeNs::AdtId(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()),
-            TypeNs::BuiltinType(it) => {
-                Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into())
+            TypeNs::SelfType(impl_id) => {
+                let generics = generics(ctx.db, impl_id.into());
+                let substs = match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => {
+                        Substs::type_params_for_generics(&generics)
+                    }
+                    TypeParamLoweringMode::Variable => Substs::bound_vars(&generics),
+                };
+                ctx.db.impl_self_ty(impl_id).subst(&substs)
             }
-            TypeNs::TypeAliasId(it) => {
-                Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into())
+            TypeNs::AdtSelfType(adt) => {
+                let generics = generics(ctx.db, adt.into());
+                let substs = match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => {
+                        Substs::type_params_for_generics(&generics)
+                    }
+                    TypeParamLoweringMode::Variable => Substs::bound_vars(&generics),
+                };
+                ctx.db.ty(adt.into()).subst(&substs)
             }
+
+            TypeNs::AdtId(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
+            TypeNs::BuiltinType(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
+            TypeNs::TypeAliasId(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
             // FIXME: report error
             TypeNs::EnumVariantId(_) => return Ty::Unknown,
         };
 
-        Ty::from_type_relative_path(db, resolver, ty, remaining_segments)
+        Ty::from_type_relative_path(ctx, ty, remaining_segments)
     }
 
-    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Ty {
+    pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_, impl HirDatabase>, path: &Path) -> Ty {
         // Resolve the path (in type namespace)
         if let Some(type_ref) = path.type_anchor() {
-            let ty = Ty::from_hir(db, resolver, &type_ref);
-            return Ty::from_type_relative_path(db, resolver, ty, path.segments());
+            let ty = Ty::from_hir(ctx, &type_ref);
+            return Ty::from_type_relative_path(ctx, ty, path.segments());
         }
         let (resolution, remaining_index) =
-            match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
+            match ctx.resolver.resolve_path_in_type_ns(ctx.db, path.mod_path()) {
                 Some(it) => it,
                 None => return Ty::Unknown,
             };
@@ -218,39 +326,44 @@ impl Ty {
             ),
             Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)),
         };
-        Ty::from_partly_resolved_hir_path(
-            db,
-            resolver,
-            resolution,
-            resolved_segment,
-            remaining_segments,
-        )
+        Ty::from_partly_resolved_hir_path(ctx, resolution, resolved_segment, remaining_segments)
     }
 
     fn select_associated_type(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         self_ty: Ty,
         segment: PathSegment<'_>,
     ) -> Ty {
-        let param_idx = match self_ty {
-            Ty::Param { idx, .. } => idx,
-            _ => return Ty::Unknown, // Error: Ambiguous associated type
-        };
-        let def = match resolver.generic_def() {
+        let def = match ctx.resolver.generic_def() {
             Some(def) => def,
             None => return Ty::Unknown, // this can't actually happen
         };
-        let predicates = db.generic_predicates_for_param(def.into(), param_idx);
-        let traits_from_env = predicates.iter().filter_map(|pred| match pred {
-            GenericPredicate::Implemented(tr) if tr.self_ty() == &self_ty => Some(tr.trait_),
+        let param_id = match self_ty {
+            Ty::Param(id) if ctx.type_param_mode == TypeParamLoweringMode::Placeholder => id,
+            Ty::Bound(idx) if ctx.type_param_mode == TypeParamLoweringMode::Variable => {
+                let generics = generics(ctx.db, def);
+                let param_id = if let Some((id, _)) = generics.iter().nth(idx as usize) {
+                    id
+                } else {
+                    return Ty::Unknown;
+                };
+                param_id
+            }
+            _ => return Ty::Unknown, // Error: Ambiguous associated type
+        };
+        let predicates = ctx.db.generic_predicates_for_param(param_id);
+        let traits_from_env = predicates.iter().filter_map(|pred| match &pred.value {
+            GenericPredicate::Implemented(tr) => Some(tr.trait_),
             _ => None,
         });
-        let traits = traits_from_env.flat_map(|t| all_super_traits(db, t));
+        let traits = traits_from_env.flat_map(|t| all_super_traits(ctx.db, t));
         for t in traits {
-            if let Some(associated_ty) = db.trait_data(t).associated_type_by_name(&segment.name) {
-                let substs =
-                    Substs::build_for_def(db, t).push(self_ty.clone()).fill_with_unknown().build();
+            if let Some(associated_ty) = ctx.db.trait_data(t).associated_type_by_name(&segment.name)
+            {
+                let substs = Substs::build_for_def(ctx.db, t)
+                    .push(self_ty.clone())
+                    .fill_with_unknown()
+                    .build();
                 // FIXME handle type parameters on the segment
                 return Ty::Projection(ProjectionTy { associated_ty, parameters: substs });
             }
@@ -259,8 +372,7 @@ impl Ty {
     }
 
     fn from_hir_path_inner(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         segment: PathSegment<'_>,
         typable: TyDefId,
     ) -> Ty {
@@ -269,15 +381,14 @@ impl Ty {
             TyDefId::AdtId(it) => Some(it.into()),
             TyDefId::TypeAliasId(it) => Some(it.into()),
         };
-        let substs = substs_from_path_segment(db, resolver, segment, generic_def, false);
-        db.ty(typable).subst(&substs)
+        let substs = substs_from_path_segment(ctx, segment, generic_def, false);
+        ctx.db.ty(typable).subst(&substs)
     }
 
     /// Collect generic arguments from a path into a `Substs`. See also
     /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
     pub(super) fn substs_from_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         path: &Path,
         // Note that we don't call `db.value_type(resolved)` here,
         // `ValueTyDefId` is just a convenient way to pass generics and
@@ -305,52 +416,49 @@ impl Ty {
                 (segment, Some(var.parent.into()))
             }
         };
-        substs_from_path_segment(db, resolver, segment, generic_def, false)
+        substs_from_path_segment(ctx, segment, generic_def, false)
     }
 }
 
 pub(super) fn substs_from_path_segment(
-    db: &impl HirDatabase,
-    resolver: &Resolver,
+    ctx: &TyLoweringContext<'_, impl HirDatabase>,
     segment: PathSegment<'_>,
     def_generic: Option<GenericDefId>,
-    add_self_param: bool,
+    _add_self_param: bool,
 ) -> Substs {
     let mut substs = Vec::new();
-    let def_generics = def_generic.map(|def| generics(db, def.into()));
-
-    let (total_len, parent_len, child_len) = def_generics.map_or((0, 0, 0), |g| g.len_split());
-    substs.extend(iter::repeat(Ty::Unknown).take(parent_len));
-    if add_self_param {
-        // FIXME this add_self_param argument is kind of a hack: Traits have the
-        // Self type as an implicit first type parameter, but it can't be
-        // actually provided in the type arguments
-        // (well, actually sometimes it can, in the form of type-relative paths: `<Foo as Default>::default()`)
-        substs.push(Ty::Unknown);
-    }
+    let def_generics = def_generic.map(|def| generics(ctx.db, def.into()));
+
+    let (parent_params, self_params, type_params, impl_trait_params) =
+        def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split());
+    substs.extend(iter::repeat(Ty::Unknown).take(parent_params));
     if let Some(generic_args) = &segment.args_and_bindings {
+        if !generic_args.has_self_type {
+            substs.extend(iter::repeat(Ty::Unknown).take(self_params));
+        }
+        let expected_num =
+            if generic_args.has_self_type { self_params + type_params } else { type_params };
+        let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 };
         // if args are provided, it should be all of them, but we can't rely on that
-        let self_param_correction = if add_self_param { 1 } else { 0 };
-        let child_len = child_len - self_param_correction;
-        for arg in generic_args.args.iter().take(child_len) {
+        for arg in generic_args.args.iter().skip(skip).take(expected_num) {
             match arg {
                 GenericArg::Type(type_ref) => {
-                    let ty = Ty::from_hir(db, resolver, type_ref);
+                    let ty = Ty::from_hir(ctx, type_ref);
                     substs.push(ty);
                 }
             }
         }
     }
+    let total_len = parent_params + self_params + type_params + impl_trait_params;
     // add placeholders for args that were not provided
-    let supplied_params = substs.len();
-    for _ in supplied_params..total_len {
+    for _ in substs.len()..total_len {
         substs.push(Ty::Unknown);
     }
     assert_eq!(substs.len(), total_len);
 
     // handle defaults
     if let Some(def_generic) = def_generic {
-        let default_substs = db.generic_defaults(def_generic.into());
+        let default_substs = ctx.db.generic_defaults(def_generic.into());
         assert_eq!(substs.len(), default_substs.len());
 
         for (i, default_ty) in default_substs.iter().enumerate() {
@@ -365,27 +473,25 @@ pub(super) fn substs_from_path_segment(
 
 impl TraitRef {
     fn from_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         path: &Path,
         explicit_self_ty: Option<Ty>,
     ) -> Option<Self> {
-        let resolved = match resolver.resolve_path_in_type_ns_fully(db, path.mod_path())? {
+        let resolved = match ctx.resolver.resolve_path_in_type_ns_fully(ctx.db, path.mod_path())? {
             TypeNs::TraitId(tr) => tr,
             _ => return None,
         };
         let segment = path.segments().last().expect("path should have at least one segment");
-        Some(TraitRef::from_resolved_path(db, resolver, resolved.into(), segment, explicit_self_ty))
+        Some(TraitRef::from_resolved_path(ctx, resolved.into(), segment, explicit_self_ty))
     }
 
     pub(crate) fn from_resolved_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         resolved: TraitId,
         segment: PathSegment<'_>,
         explicit_self_ty: Option<Ty>,
     ) -> Self {
-        let mut substs = TraitRef::substs_from_path(db, resolver, segment, resolved);
+        let mut substs = TraitRef::substs_from_path(ctx, segment, resolved);
         if let Some(self_ty) = explicit_self_ty {
             make_mut_slice(&mut substs.0)[0] = self_ty;
         }
@@ -393,8 +499,7 @@ impl TraitRef {
     }
 
     fn from_hir(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         type_ref: &TypeRef,
         explicit_self_ty: Option<Ty>,
     ) -> Option<Self> {
@@ -402,28 +507,26 @@ impl TraitRef {
             TypeRef::Path(path) => path,
             _ => return None,
         };
-        TraitRef::from_path(db, resolver, path, explicit_self_ty)
+        TraitRef::from_path(ctx, path, explicit_self_ty)
     }
 
     fn substs_from_path(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         segment: PathSegment<'_>,
         resolved: TraitId,
     ) -> Substs {
         let has_self_param =
             segment.args_and_bindings.as_ref().map(|a| a.has_self_type).unwrap_or(false);
-        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), !has_self_param)
+        substs_from_path_segment(ctx, segment, Some(resolved.into()), !has_self_param)
     }
 
     pub(crate) fn from_type_bound(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
         bound: &TypeBound,
         self_ty: Ty,
     ) -> Option<TraitRef> {
         match bound {
-            TypeBound::Path(path) => TraitRef::from_path(db, resolver, path, Some(self_ty)),
+            TypeBound::Path(path) => TraitRef::from_path(ctx, path, Some(self_ty)),
             TypeBound::Error => None,
         }
     }
@@ -431,33 +534,44 @@ impl TraitRef {
 
 impl GenericPredicate {
     pub(crate) fn from_where_predicate<'a>(
-        db: &'a impl HirDatabase,
-        resolver: &'a Resolver,
+        ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
         where_predicate: &'a WherePredicate,
     ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        let self_ty = Ty::from_hir(db, resolver, &where_predicate.type_ref);
-        GenericPredicate::from_type_bound(db, resolver, &where_predicate.bound, self_ty)
+        let self_ty = match &where_predicate.target {
+            WherePredicateTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref),
+            WherePredicateTarget::TypeParam(param_id) => {
+                let generic_def = ctx.resolver.generic_def().expect("generics in scope");
+                let generics = generics(ctx.db, generic_def);
+                let param_id = hir_def::TypeParamId { parent: generic_def, local_id: *param_id };
+                match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => Ty::Param(param_id),
+                    TypeParamLoweringMode::Variable => {
+                        let idx = generics.param_idx(param_id).expect("matching generics");
+                        Ty::Bound(idx)
+                    }
+                }
+            }
+        };
+        GenericPredicate::from_type_bound(ctx, &where_predicate.bound, self_ty)
     }
 
     pub(crate) fn from_type_bound<'a>(
-        db: &'a impl HirDatabase,
-        resolver: &'a Resolver,
+        ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
         bound: &'a TypeBound,
         self_ty: Ty,
     ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        let trait_ref = TraitRef::from_type_bound(db, &resolver, bound, self_ty);
+        let trait_ref = TraitRef::from_type_bound(ctx, bound, self_ty);
         iter::once(trait_ref.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented))
             .chain(
-                trait_ref.into_iter().flat_map(move |tr| {
-                    assoc_type_bindings_from_type_bound(db, resolver, bound, tr)
-                }),
+                trait_ref
+                    .into_iter()
+                    .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)),
             )
     }
 }
 
 fn assoc_type_bindings_from_type_bound<'a>(
-    db: &'a impl HirDatabase,
-    resolver: &'a Resolver,
+    ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
     bound: &'a TypeBound,
     trait_ref: TraitRef,
 ) -> impl Iterator<Item = GenericPredicate> + 'a {
@@ -471,21 +585,21 @@ fn assoc_type_bindings_from_type_bound<'a>(
         .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
         .map(move |(name, type_ref)| {
             let associated_ty =
-                associated_type_by_name_including_super_traits(db, trait_ref.trait_, &name);
+                associated_type_by_name_including_super_traits(ctx.db, trait_ref.trait_, &name);
             let associated_ty = match associated_ty {
                 None => return GenericPredicate::Error,
                 Some(t) => t,
             };
             let projection_ty =
                 ProjectionTy { associated_ty, parameters: trait_ref.substs.clone() };
-            let ty = Ty::from_hir(db, resolver, type_ref);
+            let ty = Ty::from_hir(ctx, type_ref);
             let projection_predicate = ProjectionPredicate { projection_ty, ty };
             GenericPredicate::Projection(projection_predicate)
         })
 }
 
 /// Build the signature of a callable item (function, struct or enum variant).
-pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
+pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> PolyFnSig {
     match def {
         CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
         CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
@@ -497,16 +611,19 @@ pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
 pub(crate) fn field_types_query(
     db: &impl HirDatabase,
     variant_id: VariantId,
-) -> Arc<ArenaMap<LocalStructFieldId, Ty>> {
+) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>> {
     let var_data = variant_data(db, variant_id);
-    let resolver = match variant_id {
-        VariantId::StructId(it) => it.resolver(db),
-        VariantId::UnionId(it) => it.resolver(db),
-        VariantId::EnumVariantId(it) => it.parent.resolver(db),
+    let (resolver, def): (_, GenericDefId) = match variant_id {
+        VariantId::StructId(it) => (it.resolver(db), it.into()),
+        VariantId::UnionId(it) => (it.resolver(db), it.into()),
+        VariantId::EnumVariantId(it) => (it.parent.resolver(db), it.parent.into()),
     };
+    let generics = generics(db, def);
     let mut res = ArenaMap::default();
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
     for (field_id, field_data) in var_data.fields().iter() {
-        res.insert(field_id, Ty::from_hir(db, &resolver, &field_data.type_ref))
+        res.insert(field_id, Binders::new(generics.len(), Ty::from_hir(&ctx, &field_data.type_ref)))
     }
     Arc::new(res)
 }
@@ -521,32 +638,43 @@ pub(crate) fn field_types_query(
 /// these are fine: `T: Foo<U::Item>, U: Foo<()>`.
 pub(crate) fn generic_predicates_for_param_query(
     db: &impl HirDatabase,
-    def: GenericDefId,
-    param_idx: u32,
-) -> Arc<[GenericPredicate]> {
-    let resolver = def.resolver(db);
+    param_id: TypeParamId,
+) -> Arc<[Binders<GenericPredicate>]> {
+    let resolver = param_id.parent.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let generics = generics(db, param_id.parent);
     resolver
         .where_predicates_in_scope()
         // we have to filter out all other predicates *first*, before attempting to lower them
-        .filter(|pred| Ty::from_hir_only_param(db, &resolver, &pred.type_ref) == Some(param_idx))
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+        .filter(|pred| match &pred.target {
+            WherePredicateTarget::TypeRef(type_ref) => {
+                Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id)
+            }
+            WherePredicateTarget::TypeParam(local_id) => *local_id == param_id.local_id,
+        })
+        .flat_map(|pred| {
+            GenericPredicate::from_where_predicate(&ctx, pred)
+                .map(|p| Binders::new(generics.len(), p))
+        })
         .collect()
 }
 
 pub(crate) fn generic_predicates_for_param_recover(
     _db: &impl HirDatabase,
     _cycle: &[String],
-    _def: &GenericDefId,
-    _param_idx: &u32,
-) -> Arc<[GenericPredicate]> {
+    _param_id: &TypeParamId,
+) -> Arc<[Binders<GenericPredicate>]> {
     Arc::new([])
 }
 
 impl TraitEnvironment {
     pub fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
+        let ctx = TyLoweringContext::new(db, &resolver)
+            .with_type_param_mode(TypeParamLoweringMode::Placeholder);
         let predicates = resolver
             .where_predicates_in_scope()
-            .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+            .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred))
             .collect::<Vec<_>>();
 
         Arc::new(TraitEnvironment { predicates })
@@ -557,57 +685,74 @@ impl TraitEnvironment {
 pub(crate) fn generic_predicates_query(
     db: &impl HirDatabase,
     def: GenericDefId,
-) -> Arc<[GenericPredicate]> {
+) -> Arc<[Binders<GenericPredicate>]> {
     let resolver = def.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let generics = generics(db, def);
     resolver
         .where_predicates_in_scope()
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+        .flat_map(|pred| {
+            GenericPredicate::from_where_predicate(&ctx, pred)
+                .map(|p| Binders::new(generics.len(), p))
+        })
         .collect()
 }
 
 /// Resolve the default type params from generics
 pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) -> Substs {
     let resolver = def.resolver(db);
+    let ctx = TyLoweringContext::new(db, &resolver);
     let generic_params = generics(db, def.into());
 
     let defaults = generic_params
         .iter()
-        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(db, &resolver, t)))
+        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)))
         .collect();
 
     Substs(defaults)
 }
 
-fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig {
+fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> PolyFnSig {
     let data = db.function_data(def);
     let resolver = def.resolver(db);
-    let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
-    let ret = Ty::from_hir(db, &resolver, &data.ret_type);
-    FnSig::from_params_and_return(params, ret)
+    let ctx_params = TyLoweringContext::new(db, &resolver)
+        .with_impl_trait_mode(ImplTraitLoweringMode::Variable)
+        .with_type_param_mode(TypeParamLoweringMode::Variable);
+    let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::<Vec<_>>();
+    let ctx_ret = ctx_params.with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+    let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
+    let generics = generics(db, def.into());
+    let num_binders = generics.len();
+    Binders::new(num_binders, FnSig::from_params_and_return(params, ret))
 }
 
 /// Build the declared type of a function. This should not need to look at the
 /// function body.
-fn type_for_fn(db: &impl HirDatabase, def: FunctionId) -> Ty {
+fn type_for_fn(db: &impl HirDatabase, def: FunctionId) -> Binders<Ty> {
     let generics = generics(db, def.into());
-    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    let substs = Substs::bound_vars(&generics);
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
 }
 
 /// Build the declared type of a const.
-fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Ty {
+fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Binders<Ty> {
     let data = db.const_data(def);
+    let generics = generics(db, def.into());
     let resolver = def.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
 
-    Ty::from_hir(db, &resolver, &data.type_ref)
+    Binders::new(generics.len(), Ty::from_hir(&ctx, &data.type_ref))
 }
 
 /// Build the declared type of a static.
-fn type_for_static(db: &impl HirDatabase, def: StaticId) -> Ty {
+fn type_for_static(db: &impl HirDatabase, def: StaticId) -> Binders<Ty> {
     let data = db.static_data(def);
     let resolver = def.resolver(db);
+    let ctx = TyLoweringContext::new(db, &resolver);
 
-    Ty::from_hir(db, &resolver, &data.type_ref)
+    Binders::new(0, Ty::from_hir(&ctx, &data.type_ref))
 }
 
 /// Build the declared type of a static.
@@ -621,68 +766,69 @@ fn type_for_builtin(def: BuiltinType) -> Ty {
     })
 }
 
-fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig {
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> PolyFnSig {
     let struct_data = db.struct_data(def.into());
     let fields = struct_data.variant_data.fields();
     let resolver = def.resolver(db);
-    let params = fields
-        .iter()
-        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
-        .collect::<Vec<_>>();
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let params =
+        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
     let ret = type_for_adt(db, def.into());
-    FnSig::from_params_and_return(params, ret)
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
 }
 
 /// Build the type of a tuple struct constructor.
-fn type_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> Ty {
+fn type_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> Binders<Ty> {
     let struct_data = db.struct_data(def.into());
     if struct_data.variant_data.is_unit() {
         return type_for_adt(db, def.into()); // Unit struct
     }
     let generics = generics(db, def.into());
-    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    let substs = Substs::bound_vars(&generics);
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
 }
 
-fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> FnSig {
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> PolyFnSig {
     let enum_data = db.enum_data(def.parent);
     let var_data = &enum_data.variants[def.local_id];
     let fields = var_data.variant_data.fields();
     let resolver = def.parent.resolver(db);
-    let params = fields
-        .iter()
-        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
-        .collect::<Vec<_>>();
-    let generics = generics(db, def.parent.into());
-    let substs = Substs::identity(&generics);
-    let ret = type_for_adt(db, def.parent.into()).subst(&substs);
-    FnSig::from_params_and_return(params, ret)
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let params =
+        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
+    let ret = type_for_adt(db, def.parent.into());
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
 }
 
 /// Build the type of a tuple enum variant constructor.
-fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> Ty {
+fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> Binders<Ty> {
     let enum_data = db.enum_data(def.parent);
     let var_data = &enum_data.variants[def.local_id].variant_data;
     if var_data.is_unit() {
         return type_for_adt(db, def.parent.into()); // Unit variant
     }
     let generics = generics(db, def.parent.into());
-    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs)
+    let substs = Substs::bound_vars(&generics);
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs))
 }
 
-fn type_for_adt(db: &impl HirDatabase, adt: AdtId) -> Ty {
+fn type_for_adt(db: &impl HirDatabase, adt: AdtId) -> Binders<Ty> {
     let generics = generics(db, adt.into());
-    Ty::apply(TypeCtor::Adt(adt), Substs::identity(&generics))
+    let substs = Substs::bound_vars(&generics);
+    Binders::new(substs.len(), Ty::apply(TypeCtor::Adt(adt), substs))
 }
 
-fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Ty {
+fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Binders<Ty> {
     let generics = generics(db, t.into());
     let resolver = t.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
     let type_ref = &db.type_alias_data(t).type_ref;
-    let substs = Substs::identity(&generics);
-    let inner = Ty::from_hir(db, &resolver, type_ref.as_ref().unwrap_or(&TypeRef::Error));
-    inner.subst(&substs)
+    let substs = Substs::bound_vars(&generics);
+    let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
+    Binders::new(substs.len(), inner)
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -736,19 +882,24 @@ impl_froms!(ValueTyDefId: FunctionId, StructId, EnumVariantId, ConstId, StaticId
 /// `struct Foo(usize)`, we have two types: The type of the struct itself, and
 /// the constructor function `(usize) -> Foo` which lives in the values
 /// namespace.
-pub(crate) fn ty_query(db: &impl HirDatabase, def: TyDefId) -> Ty {
+pub(crate) fn ty_query(db: &impl HirDatabase, def: TyDefId) -> Binders<Ty> {
     match def {
-        TyDefId::BuiltinType(it) => type_for_builtin(it),
+        TyDefId::BuiltinType(it) => Binders::new(0, type_for_builtin(it)),
         TyDefId::AdtId(it) => type_for_adt(db, it),
         TyDefId::TypeAliasId(it) => type_for_type_alias(db, it),
     }
 }
 
-pub(crate) fn ty_recover(_db: &impl HirDatabase, _cycle: &[String], _def: &TyDefId) -> Ty {
-    Ty::Unknown
+pub(crate) fn ty_recover(db: &impl HirDatabase, _cycle: &[String], def: &TyDefId) -> Binders<Ty> {
+    let num_binders = match *def {
+        TyDefId::BuiltinType(_) => 0,
+        TyDefId::AdtId(it) => generics(db, it.into()).len(),
+        TyDefId::TypeAliasId(it) => generics(db, it.into()).len(),
+    };
+    Binders::new(num_binders, Ty::Unknown)
 }
 
-pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Ty {
+pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Binders<Ty> {
     match def {
         ValueTyDefId::FunctionId(it) => type_for_fn(db, it),
         ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it),
@@ -758,24 +909,36 @@ pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Ty {
     }
 }
 
-pub(crate) fn impl_self_ty_query(db: &impl HirDatabase, impl_id: ImplId) -> Ty {
+pub(crate) fn impl_self_ty_query(db: &impl HirDatabase, impl_id: ImplId) -> Binders<Ty> {
     let impl_data = db.impl_data(impl_id);
     let resolver = impl_id.resolver(db);
-    Ty::from_hir(db, &resolver, &impl_data.target_type)
+    let generics = generics(db, impl_id.into());
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    Binders::new(generics.len(), Ty::from_hir(&ctx, &impl_data.target_type))
 }
 
 pub(crate) fn impl_self_ty_recover(
-    _db: &impl HirDatabase,
+    db: &impl HirDatabase,
     _cycle: &[String],
-    _impl_id: &ImplId,
-) -> Ty {
-    Ty::Unknown
+    impl_id: &ImplId,
+) -> Binders<Ty> {
+    let generics = generics(db, (*impl_id).into());
+    Binders::new(generics.len(), Ty::Unknown)
 }
 
-pub(crate) fn impl_trait_query(db: &impl HirDatabase, impl_id: ImplId) -> Option<TraitRef> {
+pub(crate) fn impl_trait_query(
+    db: &impl HirDatabase,
+    impl_id: ImplId,
+) -> Option<Binders<TraitRef>> {
     let impl_data = db.impl_data(impl_id);
     let resolver = impl_id.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
     let self_ty = db.impl_self_ty(impl_id);
     let target_trait = impl_data.target_trait.as_ref()?;
-    TraitRef::from_hir(db, &resolver, target_trait, Some(self_ty.clone()))
+    Some(Binders::new(
+        self_ty.num_binders,
+        TraitRef::from_hir(&ctx, target_trait, Some(self_ty.value.clone()))?,
+    ))
 }
diff --git a/crates/ra_hir_ty/src/marks.rs b/crates/ra_hir_ty/src/marks.rs
index fe74acf11..0f754eb9c 100644
--- a/crates/ra_hir_ty/src/marks.rs
+++ b/crates/ra_hir_ty/src/marks.rs
@@ -6,5 +6,4 @@ test_utils::marks!(
     type_var_resolves_to_int_var
     match_ergonomics_ref
     coerce_merge_fail_fallback
-    insert_vars_for_impl_trait
 );
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 5bacbbd7c..5283bff28 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -61,11 +61,11 @@ impl CrateImplBlocks {
             for impl_id in module_data.scope.impls() {
                 match db.impl_trait(impl_id) {
                     Some(tr) => {
-                        res.impls_by_trait.entry(tr.trait_).or_default().push(impl_id);
+                        res.impls_by_trait.entry(tr.value.trait_).or_default().push(impl_id);
                     }
                     None => {
                         let self_ty = db.impl_self_ty(impl_id);
-                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty) {
+                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty.value) {
                             res.impls.entry(self_ty_fp).or_default().push(impl_id);
                         }
                     }
@@ -496,7 +496,7 @@ fn transform_receiver_ty(
         AssocContainerId::ContainerId(_) => unreachable!(),
     };
     let sig = db.callable_item_signature(function_id.into());
-    Some(sig.params()[0].clone().subst(&substs))
+    Some(sig.value.params()[0].clone().subst_bound_vars(&substs))
 }
 
 pub fn implements_trait(
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 7e99a42ed..fc5ef36a5 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -71,42 +71,42 @@ fn test2() {
     [82; 93) '{ loop {} }': T
     [84; 91) 'loop {}': !
     [89; 91) '{}': ()
-    [122; 133) '{ loop {} }': *mut [T;_]
+    [122; 133) '{ loop {} }': *mut [T; _]
     [124; 131) 'loop {}': !
     [129; 131) '{}': ()
     [160; 173) '{     gen() }': *mut [U]
-    [166; 169) 'gen': fn gen<U>() -> *mut [T;_]
-    [166; 171) 'gen()': *mut [U;_]
+    [166; 169) 'gen': fn gen<U>() -> *mut [U; _]
+    [166; 171) 'gen()': *mut [U; _]
     [186; 420) '{     ...rr); }': ()
-    [196; 199) 'arr': &[u8;_]
-    [212; 216) '&[1]': &[u8;_]
-    [213; 216) '[1]': [u8;_]
+    [196; 199) 'arr': &[u8; _]
+    [212; 216) '&[1]': &[u8; _]
+    [213; 216) '[1]': [u8; _]
     [214; 215) '1': u8
     [227; 228) 'a': &[u8]
-    [237; 240) 'arr': &[u8;_]
+    [237; 240) 'arr': &[u8; _]
     [250; 251) 'b': u8
-    [254; 255) 'f': fn f<u8>(&[T]) -> T
+    [254; 255) 'f': fn f<u8>(&[u8]) -> u8
     [254; 260) 'f(arr)': u8
-    [256; 259) 'arr': &[u8;_]
+    [256; 259) 'arr': &[u8; _]
     [270; 271) 'c': &[u8]
     [280; 287) '{ arr }': &[u8]
-    [282; 285) 'arr': &[u8;_]
+    [282; 285) 'arr': &[u8; _]
     [297; 298) 'd': u8
-    [301; 302) 'g': fn g<u8>(S<&[T]>) -> T
+    [301; 302) 'g': fn g<u8>(S<&[u8]>) -> u8
     [301; 316) 'g(S { a: arr })': u8
     [303; 315) 'S { a: arr }': S<&[u8]>
-    [310; 313) 'arr': &[u8;_]
-    [326; 327) 'e': [&[u8];_]
-    [341; 346) '[arr]': [&[u8];_]
-    [342; 345) 'arr': &[u8;_]
-    [356; 357) 'f': [&[u8];_]
-    [371; 379) '[arr; 2]': [&[u8];_]
-    [372; 375) 'arr': &[u8;_]
+    [310; 313) 'arr': &[u8; _]
+    [326; 327) 'e': [&[u8]; _]
+    [341; 346) '[arr]': [&[u8]; _]
+    [342; 345) 'arr': &[u8; _]
+    [356; 357) 'f': [&[u8]; _]
+    [371; 379) '[arr; 2]': [&[u8]; _]
+    [372; 375) 'arr': &[u8; _]
     [377; 378) '2': usize
     [389; 390) 'g': (&[u8], &[u8])
     [407; 417) '(arr, arr)': (&[u8], &[u8])
-    [408; 411) 'arr': &[u8;_]
-    [413; 416) 'arr': &[u8;_]
+    [408; 411) 'arr': &[u8; _]
+    [413; 416) 'arr': &[u8; _]
     "###
     );
 }
@@ -122,8 +122,8 @@ fn test() {
         @r###"
     [11; 40) '{     ...[1]; }': ()
     [21; 22) 'x': &[i32]
-    [33; 37) '&[1]': &[i32;_]
-    [34; 37) '[1]': [i32;_]
+    [33; 37) '&[1]': &[i32; _]
+    [34; 37) '[1]': [i32; _]
     [35; 36) '1': i32
     "###);
 }
@@ -159,22 +159,22 @@ fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
     [334; 335) 'x': C<[T]>
     [355; 360) '{ x }': C<[T]>
     [357; 358) 'x': C<[T]>
-    [370; 371) 'a': A<[u8;_]>
-    [385; 386) 'b': B<[u8;_]>
-    [400; 401) 'c': C<[u8;_]>
+    [370; 371) 'a': A<[u8; _]>
+    [385; 386) 'b': B<[u8; _]>
+    [400; 401) 'c': C<[u8; _]>
     [415; 481) '{     ...(c); }': ()
     [425; 426) 'd': A<[{unknown}]>
-    [429; 433) 'foo1': fn foo1<{unknown}>(A<[T]>) -> A<[T]>
+    [429; 433) 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
     [429; 436) 'foo1(a)': A<[{unknown}]>
-    [434; 435) 'a': A<[u8;_]>
+    [434; 435) 'a': A<[u8; _]>
     [446; 447) 'e': B<[u8]>
-    [450; 454) 'foo2': fn foo2<u8>(B<[T]>) -> B<[T]>
+    [450; 454) 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
     [450; 457) 'foo2(b)': B<[u8]>
-    [455; 456) 'b': B<[u8;_]>
+    [455; 456) 'b': B<[u8; _]>
     [467; 468) 'f': C<[u8]>
-    [471; 475) 'foo3': fn foo3<u8>(C<[T]>) -> C<[T]>
+    [471; 475) 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
     [471; 478) 'foo3(c)': C<[u8]>
-    [476; 477) 'c': C<[u8;_]>
+    [476; 477) 'c': C<[u8; _]>
     "###
     );
 }
@@ -202,14 +202,14 @@ fn test() {
     [64; 123) 'if tru...     }': &[i32]
     [67; 71) 'true': bool
     [72; 97) '{     ...     }': &[i32]
-    [82; 85) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [82; 85) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [82; 91) 'foo(&[1])': &[i32]
-    [86; 90) '&[1]': &[i32;_]
-    [87; 90) '[1]': [i32;_]
+    [86; 90) '&[1]': &[i32; _]
+    [87; 90) '[1]': [i32; _]
     [88; 89) '1': i32
-    [103; 123) '{     ...     }': &[i32;_]
-    [113; 117) '&[1]': &[i32;_]
-    [114; 117) '[1]': [i32;_]
+    [103; 123) '{     ...     }': &[i32; _]
+    [113; 117) '&[1]': &[i32; _]
+    [114; 117) '[1]': [i32; _]
     [115; 116) '1': i32
     "###
     );
@@ -237,15 +237,15 @@ fn test() {
     [60; 61) 'x': &[i32]
     [64; 123) 'if tru...     }': &[i32]
     [67; 71) 'true': bool
-    [72; 92) '{     ...     }': &[i32;_]
-    [82; 86) '&[1]': &[i32;_]
-    [83; 86) '[1]': [i32;_]
+    [72; 92) '{     ...     }': &[i32; _]
+    [82; 86) '&[1]': &[i32; _]
+    [83; 86) '[1]': [i32; _]
     [84; 85) '1': i32
     [98; 123) '{     ...     }': &[i32]
-    [108; 111) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [108; 111) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [108; 117) 'foo(&[1])': &[i32]
-    [112; 116) '&[1]': &[i32;_]
-    [113; 116) '[1]': [i32;_]
+    [112; 116) '&[1]': &[i32; _]
+    [113; 116) '[1]': [i32; _]
     [114; 115) '1': i32
     "###
     );
@@ -275,18 +275,18 @@ fn test(i: i32) {
     [70; 147) 'match ...     }': &[i32]
     [76; 77) 'i': i32
     [88; 89) '2': i32
-    [93; 96) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [93; 102) 'foo(&[2])': &[i32]
-    [97; 101) '&[2]': &[i32;_]
-    [98; 101) '[2]': [i32;_]
+    [97; 101) '&[2]': &[i32; _]
+    [98; 101) '[2]': [i32; _]
     [99; 100) '2': i32
     [112; 113) '1': i32
-    [117; 121) '&[1]': &[i32;_]
-    [118; 121) '[1]': [i32;_]
+    [117; 121) '&[1]': &[i32; _]
+    [118; 121) '[1]': [i32; _]
     [119; 120) '1': i32
     [131; 132) '_': i32
-    [136; 140) '&[3]': &[i32;_]
-    [137; 140) '[3]': [i32;_]
+    [136; 140) '&[3]': &[i32; _]
+    [137; 140) '[3]': [i32; _]
     [138; 139) '3': i32
     "###
     );
@@ -316,18 +316,18 @@ fn test(i: i32) {
     [70; 147) 'match ...     }': &[i32]
     [76; 77) 'i': i32
     [88; 89) '1': i32
-    [93; 97) '&[1]': &[i32;_]
-    [94; 97) '[1]': [i32;_]
+    [93; 97) '&[1]': &[i32; _]
+    [94; 97) '[1]': [i32; _]
     [95; 96) '1': i32
     [107; 108) '2': i32
-    [112; 115) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [112; 121) 'foo(&[2])': &[i32]
-    [116; 120) '&[2]': &[i32;_]
-    [117; 120) '[2]': [i32;_]
+    [116; 120) '&[2]': &[i32; _]
+    [117; 120) '[2]': [i32; _]
     [118; 119) '2': i32
     [131; 132) '_': i32
-    [136; 140) '&[3]': &[i32;_]
-    [137; 140) '[3]': [i32;_]
+    [136; 140) '&[3]': &[i32; _]
+    [137; 140) '[3]': [i32; _]
     [138; 139) '3': i32
     "###
     );
@@ -438,16 +438,16 @@ fn test() {
     [43; 45) '*x': T
     [44; 45) 'x': &T
     [58; 127) '{     ...oo); }': ()
-    [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T
+    [64; 73) 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
     [64; 79) 'takes_ref(&Foo)': Foo
     [74; 78) '&Foo': &Foo
     [75; 78) 'Foo': Foo
-    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T
+    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
     [85; 101) 'takes_...&&Foo)': &Foo
     [95; 100) '&&Foo': &&Foo
     [96; 100) '&Foo': &Foo
     [97; 100) 'Foo': Foo
-    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T
+    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
     [107; 124) 'takes_...&&Foo)': &&Foo
     [117; 123) '&&&Foo': &&&Foo
     [118; 123) '&&Foo': &&Foo
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index ce9a06fde..1722563aa 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -27,7 +27,7 @@ fn test() {
     [66; 73) 'loop {}': !
     [71; 73) '{}': ()
     [133; 160) '{     ...o"); }': ()
-    [139; 149) '<[_]>::foo': fn foo<u8>(&[T]) -> T
+    [139; 149) '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
     [139; 157) '<[_]>:..."foo")': u8
     [150; 156) 'b"foo"': &[u8]
     "###
@@ -175,7 +175,7 @@ fn test() {
     [98; 101) 'val': T
     [123; 155) '{     ...32); }': ()
     [133; 134) 'a': Gen<u32>
-    [137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
+    [137; 146) 'Gen::make': fn make<u32>(u32) -> Gen<u32>
     [137; 152) 'Gen::make(0u32)': Gen<u32>
     [147; 151) '0u32': u32
     "###
@@ -206,7 +206,7 @@ fn test() {
     [95; 98) '{ }': ()
     [118; 146) '{     ...e(); }': ()
     [128; 129) 'a': Gen<u32>
-    [132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
+    [132; 141) 'Gen::make': fn make<u32>() -> Gen<u32>
     [132; 143) 'Gen::make()': Gen<u32>
     "###
     );
@@ -260,7 +260,7 @@ fn test() {
     [91; 94) '{ }': ()
     [114; 149) '{     ...e(); }': ()
     [124; 125) 'a': Gen<u32>
-    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<T>
+    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<u32>
     [128; 146) 'Gen::<...make()': Gen<u32>
     "###
     );
@@ -291,7 +291,7 @@ fn test() {
     [117; 120) '{ }': ()
     [140; 180) '{     ...e(); }': ()
     [150; 151) 'a': Gen<u32, u64>
-    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, T>
+    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
     [154; 177) 'Gen::<...make()': Gen<u32, u64>
     "###
     );
@@ -475,7 +475,7 @@ fn test() {
         @r###"
     [33; 37) 'self': &Self
     [102; 127) '{     ...d(); }': ()
-    [108; 109) 'S': S<u32>(T) -> S<T>
+    [108; 109) 'S': S<u32>(u32) -> S<u32>
     [108; 115) 'S(1u32)': S<u32>
     [108; 124) 'S(1u32...thod()': u32
     [110; 114) '1u32': u32
@@ -501,13 +501,13 @@ fn test() {
         @r###"
     [87; 193) '{     ...t(); }': ()
     [97; 99) 's1': S
-    [105; 121) 'Defaul...efault': fn default<S>() -> Self
+    [105; 121) 'Defaul...efault': fn default<S>() -> S
     [105; 123) 'Defaul...ault()': S
     [133; 135) 's2': S
-    [138; 148) 'S::default': fn default<S>() -> Self
+    [138; 148) 'S::default': fn default<S>() -> S
     [138; 150) 'S::default()': S
     [160; 162) 's3': S
-    [165; 188) '<S as ...efault': fn default<S>() -> Self
+    [165; 188) '<S as ...efault': fn default<S>() -> S
     [165; 190) '<S as ...ault()': S
     "###
     );
@@ -533,13 +533,13 @@ fn test() {
         @r###"
     [127; 211) '{     ...e(); }': ()
     [137; 138) 'a': u32
-    [141; 148) 'S::make': fn make<S, u32>() -> T
+    [141; 148) 'S::make': fn make<S, u32>() -> u32
     [141; 150) 'S::make()': u32
     [160; 161) 'b': u64
-    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> T
+    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
     [164; 180) 'G::<u6...make()': u64
     [190; 191) 'c': f64
-    [199; 206) 'G::make': fn make<G<f64>, f64>() -> T
+    [199; 206) 'G::make': fn make<G<f64>, f64>() -> f64
     [199; 208) 'G::make()': f64
     "###
     );
@@ -567,19 +567,19 @@ fn test() {
         @r###"
     [135; 313) '{     ...e(); }': ()
     [145; 146) 'a': (u32, i64)
-    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (T, U)
+    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
     [149; 165) 'S::mak...i64>()': (u32, i64)
     [175; 176) 'b': (u32, i64)
-    [189; 196) 'S::make': fn make<S, u32, i64>() -> (T, U)
+    [189; 196) 'S::make': fn make<S, u32, i64>() -> (u32, i64)
     [189; 198) 'S::make()': (u32, i64)
     [208; 209) 'c': (u32, i64)
-    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [212; 235) 'G::<u3...i64>()': (u32, i64)
     [245; 246) 'd': (u32, i64)
-    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [259; 275) 'G::mak...i64>()': (u32, i64)
     [285; 286) 'e': (u32, i64)
-    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (T, U)
+    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [301; 310) 'G::make()': (u32, i64)
     "###
     );
@@ -601,7 +601,7 @@ fn test() {
         @r###"
     [101; 127) '{     ...e(); }': ()
     [111; 112) 'a': (S<i32>, i64)
-    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (Self, T)
+    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
     [115; 124) 'S::make()': (S<i32>, i64)
     "###
     );
@@ -625,10 +625,10 @@ fn test() {
         @r###"
     [131; 203) '{     ...e(); }': ()
     [141; 142) 'a': (S<u64>, i64)
-    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (Self, T)
+    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
     [158; 167) 'S::make()': (S<u64>, i64)
     [177; 178) 'b': (S<u32>, i32)
-    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (Self, T)
+    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
     [191; 200) 'S::make()': (S<u32>, i32)
     "###
     );
@@ -651,10 +651,10 @@ fn test() {
         @r###"
     [107; 211) '{     ...>(); }': ()
     [117; 118) 'a': (S<u64>, i64, u8)
-    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
     [121; 152) '<S as ...<u8>()': (S<u64>, i64, u8)
     [162; 163) 'b': (S<u64>, i64, u8)
-    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
     [182; 208) 'Trait:...<u8>()': (S<u64>, i64, u8)
     "###
     );
@@ -697,7 +697,7 @@ fn test<U, T: Trait<U>>(t: T) {
     [71; 72) 't': T
     [77; 96) '{     ...d(); }': ()
     [83; 84) 't': T
-    [83; 93) 't.method()': [missing name]
+    [83; 93) 't.method()': U
     "###
     );
 }
@@ -728,7 +728,7 @@ fn test() {
     [157; 158) 'S': S
     [157; 165) 'S.into()': u64
     [175; 176) 'z': u64
-    [179; 196) 'Into::...::into': fn into<S, u64>(Self) -> T
+    [179; 196) 'Into::...::into': fn into<S, u64>(S) -> u64
     [179; 199) 'Into::...nto(S)': u64
     [197; 198) 'S': S
     "###
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index cb3890b42..e25d6dbc4 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -96,13 +96,13 @@ fn test() {
     [38; 42) 'A(n)': A<i32>
     [40; 41) 'n': &i32
     [45; 50) '&A(1)': &A<i32>
-    [46; 47) 'A': A<i32>(T) -> A<T>
+    [46; 47) 'A': A<i32>(i32) -> A<i32>
     [46; 50) 'A(1)': A<i32>
     [48; 49) '1': i32
     [60; 64) 'A(n)': A<i32>
     [62; 63) 'n': &mut i32
     [67; 76) '&mut A(1)': &mut A<i32>
-    [72; 73) 'A': A<i32>(T) -> A<T>
+    [72; 73) 'A': A<i32>(i32) -> A<i32>
     [72; 76) 'A(1)': A<i32>
     [74; 75) '1': i32
     "###
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index aa948dcbf..14c8ed3a9 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -102,7 +102,7 @@ fn test() {
     [11; 48) '{     ...&y]; }': ()
     [21; 22) 'y': &{unknown}
     [25; 32) 'unknown': &{unknown}
-    [38; 45) '[y, &y]': [&&{unknown};_]
+    [38; 45) '[y, &y]': [&&{unknown}; _]
     [39; 40) 'y': &{unknown}
     [42; 44) '&y': &&{unknown}
     [43; 44) 'y': &{unknown}
@@ -128,7 +128,7 @@ fn test() {
     [25; 32) 'unknown': &&{unknown}
     [42; 43) 'y': &&{unknown}
     [46; 53) 'unknown': &&{unknown}
-    [59; 77) '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown});_]
+    [59; 77) '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown}); _]
     [60; 66) '(x, y)': (&&&{unknown}, &&&{unknown})
     [61; 62) 'x': &&{unknown}
     [64; 65) 'y': &&{unknown}
@@ -180,8 +180,8 @@ fn test_line_buffer() {
 "#),
         @r###"
     [23; 53) '{     ...n']; }': ()
-    [29; 50) '&[0, b...b'\n']': &[u8;_]
-    [30; 50) '[0, b'...b'\n']': [u8;_]
+    [29; 50) '&[0, b...b'\n']': &[u8; _]
+    [30; 50) '[0, b'...b'\n']': [u8; _]
     [31; 32) '0': u8
     [34; 39) 'b'\n'': u8
     [41; 42) '1': u8
@@ -346,7 +346,7 @@ pub fn main_loop() {
     @r###"
     [144; 146) '{}': ()
     [169; 198) '{     ...t(); }': ()
-    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<T, H>
+    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
     [175; 195) 'FxHash...ault()': HashSet<{unknown}, FxHasher>
     "###
     );
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index b7204ec00..3803f5938 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -28,7 +28,7 @@ mod boxed {
 
 "#,
     );
-    assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32;_]>)", type_at_pos(&db, pos));
+    assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -754,15 +754,15 @@ fn test() {
     [289; 295) 'self.0': T
     [315; 353) '{     ...))); }': ()
     [325; 326) 't': &i32
-    [329; 335) 'A::foo': fn foo<i32>(&A<T>) -> &T
+    [329; 335) 'A::foo': fn foo<i32>(&A<i32>) -> &i32
     [329; 350) 'A::foo...42))))': &i32
     [336; 349) '&&B(B(A(42)))': &&B<B<A<i32>>>
     [337; 349) '&B(B(A(42)))': &B<B<A<i32>>>
-    [338; 339) 'B': B<B<A<i32>>>(T) -> B<T>
+    [338; 339) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
     [338; 349) 'B(B(A(42)))': B<B<A<i32>>>
-    [340; 341) 'B': B<A<i32>>(T) -> B<T>
+    [340; 341) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
     [340; 348) 'B(A(42))': B<A<i32>>
-    [342; 343) 'A': A<i32>(T) -> A<T>
+    [342; 343) 'A': A<i32>(i32) -> A<i32>
     [342; 347) 'A(42)': A<i32>
     [344; 346) '42': i32
     "###
@@ -817,16 +817,16 @@ fn test(a: A<i32>) {
     [326; 327) 'a': A<i32>
     [337; 383) '{     ...))); }': ()
     [347; 348) 't': &i32
-    [351; 352) 'A': A<i32>(*mut T) -> A<T>
+    [351; 352) 'A': A<i32>(*mut i32) -> A<i32>
     [351; 365) 'A(0 as *mut _)': A<i32>
     [351; 380) 'A(0 as...B(a)))': &i32
     [353; 354) '0': i32
     [353; 364) '0 as *mut _': *mut i32
     [370; 379) '&&B(B(a))': &&B<B<A<i32>>>
     [371; 379) '&B(B(a))': &B<B<A<i32>>>
-    [372; 373) 'B': B<B<A<i32>>>(T) -> B<T>
+    [372; 373) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
     [372; 379) 'B(B(a))': B<B<A<i32>>>
-    [374; 375) 'B': B<A<i32>>(T) -> B<T>
+    [374; 375) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
     [374; 378) 'B(a)': B<A<i32>>
     [376; 377) 'a': A<i32>
     "###
@@ -1061,55 +1061,55 @@ fn test(x: &str, y: isize) {
     [9; 10) 'x': &str
     [18; 19) 'y': isize
     [28; 293) '{     ... []; }': ()
-    [38; 39) 'a': [&str;_]
-    [42; 45) '[x]': [&str;_]
+    [38; 39) 'a': [&str; _]
+    [42; 45) '[x]': [&str; _]
     [43; 44) 'x': &str
-    [55; 56) 'b': [[&str;_];_]
-    [59; 65) '[a, a]': [[&str;_];_]
-    [60; 61) 'a': [&str;_]
-    [63; 64) 'a': [&str;_]
-    [75; 76) 'c': [[[&str;_];_];_]
-    [79; 85) '[b, b]': [[[&str;_];_];_]
-    [80; 81) 'b': [[&str;_];_]
-    [83; 84) 'b': [[&str;_];_]
-    [96; 97) 'd': [isize;_]
-    [100; 112) '[y, 1, 2, 3]': [isize;_]
+    [55; 56) 'b': [[&str; _]; _]
+    [59; 65) '[a, a]': [[&str; _]; _]
+    [60; 61) 'a': [&str; _]
+    [63; 64) 'a': [&str; _]
+    [75; 76) 'c': [[[&str; _]; _]; _]
+    [79; 85) '[b, b]': [[[&str; _]; _]; _]
+    [80; 81) 'b': [[&str; _]; _]
+    [83; 84) 'b': [[&str; _]; _]
+    [96; 97) 'd': [isize; _]
+    [100; 112) '[y, 1, 2, 3]': [isize; _]
     [101; 102) 'y': isize
     [104; 105) '1': isize
     [107; 108) '2': isize
     [110; 111) '3': isize
-    [122; 123) 'd': [isize;_]
-    [126; 138) '[1, y, 2, 3]': [isize;_]
+    [122; 123) 'd': [isize; _]
+    [126; 138) '[1, y, 2, 3]': [isize; _]
     [127; 128) '1': isize
     [130; 131) 'y': isize
     [133; 134) '2': isize
     [136; 137) '3': isize
-    [148; 149) 'e': [isize;_]
-    [152; 155) '[y]': [isize;_]
+    [148; 149) 'e': [isize; _]
+    [152; 155) '[y]': [isize; _]
     [153; 154) 'y': isize
-    [165; 166) 'f': [[isize;_];_]
-    [169; 175) '[d, d]': [[isize;_];_]
-    [170; 171) 'd': [isize;_]
-    [173; 174) 'd': [isize;_]
-    [185; 186) 'g': [[isize;_];_]
-    [189; 195) '[e, e]': [[isize;_];_]
-    [190; 191) 'e': [isize;_]
-    [193; 194) 'e': [isize;_]
-    [206; 207) 'h': [i32;_]
-    [210; 216) '[1, 2]': [i32;_]
+    [165; 166) 'f': [[isize; _]; _]
+    [169; 175) '[d, d]': [[isize; _]; _]
+    [170; 171) 'd': [isize; _]
+    [173; 174) 'd': [isize; _]
+    [185; 186) 'g': [[isize; _]; _]
+    [189; 195) '[e, e]': [[isize; _]; _]
+    [190; 191) 'e': [isize; _]
+    [193; 194) 'e': [isize; _]
+    [206; 207) 'h': [i32; _]
+    [210; 216) '[1, 2]': [i32; _]
     [211; 212) '1': i32
     [214; 215) '2': i32
-    [226; 227) 'i': [&str;_]
-    [230; 240) '["a", "b"]': [&str;_]
+    [226; 227) 'i': [&str; _]
+    [230; 240) '["a", "b"]': [&str; _]
     [231; 234) '"a"': &str
     [236; 239) '"b"': &str
-    [251; 252) 'b': [[&str;_];_]
-    [255; 265) '[a, ["b"]]': [[&str;_];_]
-    [256; 257) 'a': [&str;_]
-    [259; 264) '["b"]': [&str;_]
+    [251; 252) 'b': [[&str; _]; _]
+    [255; 265) '[a, ["b"]]': [[&str; _]; _]
+    [256; 257) 'a': [&str; _]
+    [259; 264) '["b"]': [&str; _]
     [260; 263) '"b"': &str
-    [275; 276) 'x': [u8;_]
-    [288; 290) '[]': [u8;_]
+    [275; 276) 'x': [u8; _]
+    [288; 290) '[]': [u8; _]
     "###
     );
 }
@@ -1169,16 +1169,16 @@ fn test() {
 "#),
         @r###"
     [76; 184) '{     ...one; }': ()
-    [82; 83) 'A': A<i32>(T) -> A<T>
+    [82; 83) 'A': A<i32>(i32) -> A<i32>
     [82; 87) 'A(42)': A<i32>
     [84; 86) '42': i32
-    [93; 94) 'A': A<u128>(T) -> A<T>
+    [93; 94) 'A': A<u128>(u128) -> A<u128>
     [93; 102) 'A(42u128)': A<u128>
     [95; 101) '42u128': u128
-    [108; 112) 'Some': Some<&str>(T) -> Option<T>
+    [108; 112) 'Some': Some<&str>(&str) -> Option<&str>
     [108; 117) 'Some("x")': Option<&str>
     [113; 116) '"x"': &str
-    [123; 135) 'Option::Some': Some<&str>(T) -> Option<T>
+    [123; 135) 'Option::Some': Some<&str>(&str) -> Option<&str>
     [123; 140) 'Option...e("x")': Option<&str>
     [136; 139) '"x"': &str
     [146; 150) 'None': Option<{unknown}>
@@ -1205,14 +1205,14 @@ fn test() {
     [21; 26) '{ t }': T
     [23; 24) 't': T
     [38; 98) '{     ...(1); }': ()
-    [44; 46) 'id': fn id<u32>(T) -> T
+    [44; 46) 'id': fn id<u32>(u32) -> u32
     [44; 52) 'id(1u32)': u32
     [47; 51) '1u32': u32
-    [58; 68) 'id::<i128>': fn id<i128>(T) -> T
+    [58; 68) 'id::<i128>': fn id<i128>(i128) -> i128
     [58; 71) 'id::<i128>(1)': i128
     [69; 70) '1': i128
     [81; 82) 'x': u64
-    [90; 92) 'id': fn id<u64>(T) -> T
+    [90; 92) 'id': fn id<u64>(u64) -> u64
     [90; 95) 'id(1)': u64
     [93; 94) '1': u64
     "###
@@ -1220,7 +1220,7 @@ fn test() {
 }
 
 #[test]
-fn infer_impl_generics() {
+fn infer_impl_generics_basic() {
     assert_snapshot!(
         infer(r#"
 struct A<T1, T2> {
@@ -1349,16 +1349,16 @@ fn test() -> i128 {
     [146; 147) 'x': i128
     [150; 151) '1': i128
     [162; 163) 'y': i128
-    [166; 168) 'id': fn id<i128>(T) -> T
+    [166; 168) 'id': fn id<i128>(i128) -> i128
     [166; 171) 'id(x)': i128
     [169; 170) 'x': i128
     [182; 183) 'a': A<i128>
     [186; 200) 'A { x: id(y) }': A<i128>
-    [193; 195) 'id': fn id<i128>(T) -> T
+    [193; 195) 'id': fn id<i128>(i128) -> i128
     [193; 198) 'id(y)': i128
     [196; 197) 'y': i128
     [211; 212) 'z': i128
-    [215; 217) 'id': fn id<i128>(T) -> T
+    [215; 217) 'id': fn id<i128>(i128) -> i128
     [215; 222) 'id(a.x)': i128
     [218; 219) 'a': A<i128>
     [218; 221) 'a.x': i128
@@ -1502,14 +1502,14 @@ fn test() {
     [78; 158) '{     ...(1); }': ()
     [88; 89) 'y': u32
     [92; 97) '10u32': u32
-    [103; 105) 'id': fn id<u32>(T) -> T
+    [103; 105) 'id': fn id<u32>(u32) -> u32
     [103; 108) 'id(y)': u32
     [106; 107) 'y': u32
     [118; 119) 'x': bool
-    [128; 133) 'clone': fn clone<bool>(&T) -> T
+    [128; 133) 'clone': fn clone<bool>(&bool) -> bool
     [128; 136) 'clone(z)': bool
     [134; 135) 'z': &bool
-    [142; 152) 'id::<i128>': fn id<i128>(T) -> T
+    [142; 152) 'id::<i128>': fn id<i128>(i128) -> i128
     [142; 155) 'id::<i128>(1)': i128
     [153; 154) '1': i128
     "###
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 4b268510c..17611ddbf 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,7 +1,6 @@
 use insta::assert_snapshot;
 
 use ra_db::fixture::WithFixture;
-use test_utils::covers;
 
 use super::{infer, infer_with_mismatches, type_at, type_at_pos};
 use crate::test_db::TestDB;
@@ -261,10 +260,10 @@ fn test() {
     [92; 94) '{}': ()
     [105; 144) '{     ...(s); }': ()
     [115; 116) 's': S<u32>
-    [119; 120) 'S': S<u32>(T) -> S<T>
+    [119; 120) 'S': S<u32>(u32) -> S<u32>
     [119; 129) 'S(unknown)': S<u32>
     [121; 128) 'unknown': u32
-    [135; 138) 'foo': fn foo<S<u32>>(T) -> ()
+    [135; 138) 'foo': fn foo<S<u32>>(S<u32>) -> ()
     [135; 141) 'foo(s)': ()
     [139; 140) 's': S<u32>
     "###
@@ -289,11 +288,11 @@ fn test() {
     [98; 100) '{}': ()
     [111; 163) '{     ...(s); }': ()
     [121; 122) 's': S<u32>
-    [125; 126) 'S': S<u32>(T) -> S<T>
+    [125; 126) 'S': S<u32>(u32) -> S<u32>
     [125; 135) 'S(unknown)': S<u32>
     [127; 134) 'unknown': u32
     [145; 146) 'x': u32
-    [154; 157) 'foo': fn foo<u32, S<u32>>(T) -> U
+    [154; 157) 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
     [154; 160) 'foo(s)': u32
     [158; 159) 's': S<u32>
     "###
@@ -358,15 +357,15 @@ fn test() {
     [221; 223) '{}': ()
     [234; 300) '{     ...(S); }': ()
     [244; 245) 'x': u32
-    [248; 252) 'foo1': fn foo1<S>(T) -> <T as Iterable>::Item
+    [248; 252) 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
     [248; 255) 'foo1(S)': u32
     [253; 254) 'S': S
     [265; 266) 'y': u32
-    [269; 273) 'foo2': fn foo2<S>(T) -> <T as Iterable>::Item
+    [269; 273) 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
     [269; 276) 'foo2(S)': u32
     [274; 275) 'S': S
     [286; 287) 'z': u32
-    [290; 294) 'foo3': fn foo3<S>(T) -> <T as Iterable>::Item
+    [290; 294) 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
     [290; 297) 'foo3(S)': u32
     [295; 296) 'S': S
     "###
@@ -479,7 +478,7 @@ fn indexing_arrays() {
         @r###"
     [10; 26) '{ &mut...[2]; }': ()
     [12; 23) '&mut [9][2]': &mut {unknown}
-    [17; 20) '[9]': [i32;_]
+    [17; 20) '[9]': [i32; _]
     [17; 23) '[9][2]': {unknown}
     [18; 19) '9': i32
     [21; 22) '2': i32
@@ -822,8 +821,7 @@ fn test<T: ApplyL>() {
 "#,
     );
     // 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].
-    // FIXME: fix type parameter names going missing when going through Chalk
-    assert_eq!(t, "ApplyL::Out<[missing name]>");
+    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
@@ -850,6 +848,198 @@ fn test<T: ApplyL>(t: T) {
 }
 
 #[test]
+fn argument_impl_trait() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait<T> {
+    fn foo(&self) -> T;
+    fn foo2(&self) -> i64;
+}
+fn bar(x: impl Trait<u16>) {}
+struct S<T>(T);
+impl<T> Trait<T> for S<T> {}
+
+fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
+    x;
+    y;
+    let z = S(1);
+    bar(z);
+    x.foo();
+    y.foo();
+    z.foo();
+    x.foo2();
+    y.foo2();
+    z.foo2();
+}
+"#, true),
+        @r###"
+    [30; 34) 'self': &Self
+    [55; 59) 'self': &Self
+    [78; 79) 'x': impl Trait<u16>
+    [98; 100) '{}': ()
+    [155; 156) 'x': impl Trait<u64>
+    [175; 176) 'y': &impl Trait<u32>
+    [196; 324) '{     ...2(); }': ()
+    [202; 203) 'x': impl Trait<u64>
+    [209; 210) 'y': &impl Trait<u32>
+    [220; 221) 'z': S<u16>
+    [224; 225) 'S': S<u16>(u16) -> S<u16>
+    [224; 228) 'S(1)': S<u16>
+    [226; 227) '1': u16
+    [234; 237) 'bar': fn bar(S<u16>) -> ()
+    [234; 240) 'bar(z)': ()
+    [238; 239) 'z': S<u16>
+    [246; 247) 'x': impl Trait<u64>
+    [246; 253) 'x.foo()': u64
+    [259; 260) 'y': &impl Trait<u32>
+    [259; 266) 'y.foo()': u32
+    [272; 273) 'z': S<u16>
+    [272; 279) 'z.foo()': u16
+    [285; 286) 'x': impl Trait<u64>
+    [285; 293) 'x.foo2()': i64
+    [299; 300) 'y': &impl Trait<u32>
+    [299; 307) 'y.foo2()': i64
+    [313; 314) 'z': S<u16>
+    [313; 321) 'z.foo2()': i64
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_type_args_1() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+trait Foo {
+    // this function has an implicit Self param, an explicit type param,
+    // and an implicit impl Trait param!
+    fn bar<T>(x: impl Trait) -> T { loop {} }
+}
+fn foo<T>(x: impl Trait) -> T { loop {} }
+struct S;
+impl Trait for S {}
+struct F;
+impl Foo for F {}
+
+fn test() {
+    Foo::bar(S);
+    <F as Foo>::bar(S);
+    F::bar(S);
+    Foo::bar::<u32>(S);
+    <F as Foo>::bar::<u32>(S);
+
+    foo(S);
+    foo::<u32>(S);
+    foo::<u32, i32>(S); // we should ignore the extraneous i32
+}
+"#, true),
+        @r###"
+    [156; 157) 'x': impl Trait
+    [176; 187) '{ loop {} }': T
+    [178; 185) 'loop {}': !
+    [183; 185) '{}': ()
+    [200; 201) 'x': impl Trait
+    [220; 231) '{ loop {} }': T
+    [222; 229) 'loop {}': !
+    [227; 229) '{}': ()
+    [301; 510) '{     ... i32 }': ()
+    [307; 315) 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
+    [307; 318) 'Foo::bar(S)': {unknown}
+    [316; 317) 'S': S
+    [324; 339) '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    [324; 342) '<F as ...bar(S)': {unknown}
+    [340; 341) 'S': S
+    [348; 354) 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    [348; 357) 'F::bar(S)': {unknown}
+    [355; 356) 'S': S
+    [363; 378) 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
+    [363; 381) 'Foo::b...32>(S)': u32
+    [379; 380) 'S': S
+    [387; 409) '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
+    [387; 412) '<F as ...32>(S)': u32
+    [410; 411) 'S': S
+    [419; 422) 'foo': fn foo<{unknown}>(S) -> {unknown}
+    [419; 425) 'foo(S)': {unknown}
+    [423; 424) 'S': S
+    [431; 441) 'foo::<u32>': fn foo<u32>(S) -> u32
+    [431; 444) 'foo::<u32>(S)': u32
+    [442; 443) 'S': S
+    [450; 465) 'foo::<u32, i32>': fn foo<u32>(S) -> u32
+    [450; 468) 'foo::<...32>(S)': u32
+    [466; 467) 'S': S
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_type_args_2() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+struct S;
+impl Trait for S {}
+struct F<T>;
+impl<T> F<T> {
+    fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
+}
+
+fn test() {
+    F.foo(S);
+    F::<u32>.foo(S);
+    F::<u32>.foo::<i32>(S);
+    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+}
+"#, true),
+        @r###"
+    [88; 92) 'self': F<T>
+    [94; 95) 'x': impl Trait
+    [119; 130) '{ loop {} }': (T, U)
+    [121; 128) 'loop {}': !
+    [126; 128) '{}': ()
+    [144; 284) '{     ...ored }': ()
+    [150; 151) 'F': F<{unknown}>
+    [150; 158) 'F.foo(S)': ({unknown}, {unknown})
+    [156; 157) 'S': S
+    [164; 172) 'F::<u32>': F<u32>
+    [164; 179) 'F::<u32>.foo(S)': (u32, {unknown})
+    [177; 178) 'S': S
+    [185; 193) 'F::<u32>': F<u32>
+    [185; 207) 'F::<u3...32>(S)': (u32, i32)
+    [205; 206) 'S': S
+    [213; 221) 'F::<u32>': F<u32>
+    [213; 240) 'F::<u3...32>(S)': (u32, i32)
+    [238; 239) 'S': S
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_to_fn_pointer() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+fn foo(x: impl Trait) { loop {} }
+struct S;
+impl Trait for S {}
+
+fn test() {
+    let f: fn(S) -> () = foo;
+}
+"#, true),
+        @r###"
+    [23; 24) 'x': impl Trait
+    [38; 49) '{ loop {} }': ()
+    [40; 47) 'loop {}': !
+    [45; 47) '{}': ()
+    [91; 124) '{     ...foo; }': ()
+    [101; 102) 'f': fn(S) -> ()
+    [118; 121) 'foo': fn foo(S) -> ()
+    "###
+    );
+}
+
+#[test]
+#[ignore]
 fn impl_trait() {
     assert_snapshot!(
         infer(r#"
@@ -993,34 +1183,23 @@ fn weird_bounds() {
     assert_snapshot!(
         infer(r#"
 trait Trait {}
-fn test() {
-    let a: impl Trait + 'lifetime = foo;
-    let b: impl 'lifetime = foo;
-    let b: impl (Trait) = foo;
-    let b: impl ('lifetime) = foo;
-    let d: impl ?Sized = foo;
-    let e: impl Trait + ?Sized = foo;
+fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {
 }
 "#),
         @r###"
-    [26; 237) '{     ...foo; }': ()
-    [36; 37) 'a': impl Trait + {error}
-    [64; 67) 'foo': impl Trait + {error}
-    [77; 78) 'b': impl {error}
-    [97; 100) 'foo': impl {error}
-    [110; 111) 'b': impl Trait
-    [128; 131) 'foo': impl Trait
-    [141; 142) 'b': impl {error}
-    [163; 166) 'foo': impl {error}
-    [176; 177) 'd': impl {error}
-    [193; 196) 'foo': impl {error}
-    [206; 207) 'e': impl Trait + {error}
-    [231; 234) 'foo': impl Trait + {error}
+    [24; 25) 'a': impl Trait + {error}
+    [51; 52) 'b': impl {error}
+    [70; 71) 'c': impl Trait
+    [87; 88) 'd': impl {error}
+    [108; 109) 'e': impl {error}
+    [124; 125) 'f': impl Trait + {error}
+    [148; 151) '{ }': ()
     "###
     );
 }
 
 #[test]
+#[ignore]
 fn error_bound_chalk() {
     let t = type_at(
         r#"
@@ -1076,26 +1255,26 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
     [296; 299) 'get': fn get<T>(T) -> <T as Trait>::Type
     [296; 302) 'get(x)': {unknown}
     [300; 301) 'x': T
-    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> U
+    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> {unknown}
     [308; 315) 'get2(x)': {unknown}
     [313; 314) 'x': T
-    [321; 324) 'get': fn get<impl Trait<Type = i64>>(T) -> <T as Trait>::Type
+    [321; 324) 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
     [321; 327) 'get(y)': {unknown}
     [325; 326) 'y': impl Trait<Type = i64>
-    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(T) -> U
+    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> {unknown}
     [333; 340) 'get2(y)': {unknown}
     [338; 339) 'y': impl Trait<Type = i64>
-    [346; 349) 'get': fn get<S<u64>>(T) -> <T as Trait>::Type
+    [346; 349) 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
     [346; 357) 'get(set(S))': u64
-    [350; 353) 'set': fn set<S<u64>>(T) -> T
+    [350; 353) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
     [350; 356) 'set(S)': S<u64>
     [354; 355) 'S': S<u64>
-    [363; 367) 'get2': fn get2<u64, S<u64>>(T) -> U
+    [363; 367) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
     [363; 375) 'get2(set(S))': u64
-    [368; 371) 'set': fn set<S<u64>>(T) -> T
+    [368; 371) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
     [368; 374) 'set(S)': S<u64>
     [372; 373) 'S': S<u64>
-    [381; 385) 'get2': fn get2<str, S<str>>(T) -> U
+    [381; 385) 'get2': fn get2<str, S<str>>(S<str>) -> str
     [381; 395) 'get2(S::<str>)': str
     [386; 394) 'S::<str>': S<str>
     "###
@@ -1223,6 +1402,32 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
 }
 
 #[test]
+fn super_trait_impl_trait_method_resolution() {
+    assert_snapshot!(
+        infer(r#"
+mod foo {
+    trait SuperTrait {
+        fn foo(&self) -> u32 {}
+    }
+}
+trait Trait1: foo::SuperTrait {}
+
+fn test(x: &impl Trait1) {
+    x.foo();
+}
+"#),
+        @r###"
+    [50; 54) 'self': &Self
+    [63; 65) '{}': ()
+    [116; 117) 'x': &impl Trait1
+    [133; 149) '{     ...o(); }': ()
+    [139; 140) 'x': &impl Trait1
+    [139; 146) 'x.foo()': u32
+    "###
+    );
+}
+
+#[test]
 fn super_trait_cycle() {
     // This just needs to not crash
     assert_snapshot!(
@@ -1268,9 +1473,9 @@ fn test() {
     [157; 160) '{t}': T
     [158; 159) 't': T
     [259; 280) '{     ...S)); }': ()
-    [265; 269) 'get2': fn get2<u64, S<u64>>(T) -> U
+    [265; 269) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
     [265; 277) 'get2(set(S))': u64
-    [270; 273) 'set': fn set<S<u64>>(T) -> T
+    [270; 273) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
     [270; 276) 'set(S)': S<u64>
     [274; 275) 'S': S<u64>
     "###
@@ -1332,7 +1537,7 @@ fn test() {
     [173; 175) '{}': ()
     [189; 308) '{     ... 1); }': ()
     [199; 200) 'x': Option<u32>
-    [203; 215) 'Option::Some': Some<u32>(T) -> Option<T>
+    [203; 215) 'Option::Some': Some<u32>(u32) -> Option<u32>
     [203; 221) 'Option...(1u32)': Option<u32>
     [216; 220) '1u32': u32
     [227; 228) 'x': Option<u32>
@@ -1442,7 +1647,7 @@ fn test() {
     [340; 342) '{}': ()
     [356; 515) '{     ... S); }': ()
     [366; 368) 'x1': u64
-    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(T, F) -> U
+    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
     [371; 394) 'foo1(S...hod())': u64
     [376; 377) 'S': S
     [379; 393) '|s| s.method()': |S| -> u64
@@ -1450,7 +1655,7 @@ fn test() {
     [383; 384) 's': S
     [383; 393) 's.method()': u64
     [404; 406) 'x2': u64
-    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(F, T) -> U
+    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
     [409; 432) 'foo2(|...(), S)': u64
     [414; 428) '|s| s.method()': |S| -> u64
     [415; 416) 's': S
@@ -1603,7 +1808,6 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 
 #[test]
 fn unify_impl_trait() {
-    covers!(insert_vars_for_impl_trait);
     assert_snapshot!(
         infer_with_mismatches(r#"
 trait Trait<T> {}
@@ -1635,26 +1839,26 @@ fn test() -> impl Trait<i32> {
     [172; 183) '{ loop {} }': T
     [174; 181) 'loop {}': !
     [179; 181) '{}': ()
-    [214; 310) '{     ...t()) }': S<i32>
+    [214; 310) '{     ...t()) }': S<{unknown}>
     [224; 226) 's1': S<u32>
-    [229; 230) 'S': S<u32>(T) -> S<T>
+    [229; 230) 'S': S<u32>(u32) -> S<u32>
     [229; 241) 'S(default())': S<u32>
-    [231; 238) 'default': fn default<u32>() -> T
+    [231; 238) 'default': fn default<u32>() -> u32
     [231; 240) 'default()': u32
-    [247; 250) 'foo': fn foo(impl Trait<u32>) -> ()
+    [247; 250) 'foo': fn foo(S<u32>) -> ()
     [247; 254) 'foo(s1)': ()
     [251; 253) 's1': S<u32>
     [264; 265) 'x': i32
-    [273; 276) 'bar': fn bar<i32>(impl Trait<T>) -> T
+    [273; 276) 'bar': fn bar<i32>(S<i32>) -> i32
     [273; 290) 'bar(S(...lt()))': i32
-    [277; 278) 'S': S<i32>(T) -> S<T>
+    [277; 278) 'S': S<i32>(i32) -> S<i32>
     [277; 289) 'S(default())': S<i32>
-    [279; 286) 'default': fn default<i32>() -> T
+    [279; 286) 'default': fn default<i32>() -> i32
     [279; 288) 'default()': i32
-    [296; 297) 'S': S<i32>(T) -> S<T>
-    [296; 308) 'S(default())': S<i32>
-    [298; 305) 'default': fn default<i32>() -> T
-    [298; 307) 'default()': i32
+    [296; 297) 'S': S<{unknown}>({unknown}) -> S<{unknown}>
+    [296; 308) 'S(default())': S<{unknown}>
+    [298; 305) 'default': fn default<{unknown}>() -> {unknown}
+    [298; 307) 'default()': {unknown}
     "###
     );
 }
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 4aabd66dc..88af61e87 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -50,10 +50,19 @@ impl TraitSolver {
             Err(_) => ra_db::Canceled::throw(),
         };
 
+        let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
+
         let solution = panic::catch_unwind({
             let solver = panic::AssertUnwindSafe(&mut solver);
             let context = panic::AssertUnwindSafe(&context);
-            move || solver.0.solve(context.0, goal)
+            move || {
+                solver.0.solve_limited(context.0, goal, || {
+                    context.0.db.check_canceled();
+                    let remaining = fuel.get();
+                    fuel.set(remaining - 1);
+                    remaining > 0
+                })
+            }
         });
 
         let solution = match solution {
@@ -78,7 +87,9 @@ impl TraitSolver {
 /// This controls the maximum size of types Chalk considers. If we set this too
 /// high, we can run into slow edge cases; if we set it too low, Chalk won't
 /// find some solutions.
-const CHALK_SOLVER_MAX_SIZE: usize = 4;
+const CHALK_SOLVER_MAX_SIZE: usize = 10;
+/// This controls how much 'time' we give the Chalk solver before giving up.
+const CHALK_SOLVER_FUEL: i32 = 100;
 
 #[derive(Debug, Copy, Clone)]
 struct ChalkContext<'a, DB> {
@@ -97,7 +108,8 @@ pub(crate) fn trait_solver_query(
 }
 
 fn create_chalk_solver() -> chalk_solve::Solver<TypeFamily> {
-    let solver_choice = chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE };
+    let solver_choice =
+        chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE, expected_answers: None };
     solver_choice.into_solver()
 }
 
@@ -232,7 +244,6 @@ fn solution_from_chalk(
     let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<TypeFamily>>| {
         let value = subst
             .value
-            .parameters
             .into_iter()
             .map(|p| {
                 let ty = match p.ty() {
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index 555930c9b..4974c565b 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -3,7 +3,7 @@ use std::{fmt, sync::Arc};
 
 use log::debug;
 
-use chalk_ir::{cast::Cast, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
+use chalk_ir::{cast::Cast, GoalData, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
 
 use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId};
 use ra_db::{
@@ -14,7 +14,7 @@ use ra_db::{
 use super::{builtin, AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
     db::HirDatabase, display::HirDisplay, utils::generics, ApplicationTy, GenericPredicate,
-    ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+    ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
@@ -24,6 +24,8 @@ impl chalk_ir::family::TypeFamily for TypeFamily {
     type InternedType = Box<chalk_ir::TyData<Self>>;
     type InternedLifetime = chalk_ir::LifetimeData<Self>;
     type InternedParameter = chalk_ir::ParameterData<Self>;
+    type InternedGoal = Arc<GoalData<Self>>;
+    type InternedSubstitution = Vec<Parameter<Self>>;
     type DefId = InternId;
 
     // FIXME: implement these
@@ -48,8 +50,8 @@ impl chalk_ir::family::TypeFamily for TypeFamily {
         None
     }
 
-    fn debug_projection(
-        _projection: &chalk_ir::ProjectionTy<Self>,
+    fn debug_alias(
+        _projection: &chalk_ir::AliasTy<Self>,
         _fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
         None
@@ -78,6 +80,24 @@ impl chalk_ir::family::TypeFamily for TypeFamily {
     fn parameter_data(parameter: &chalk_ir::ParameterData<Self>) -> &chalk_ir::ParameterData<Self> {
         parameter
     }
+
+    fn intern_goal(goal: GoalData<Self>) -> Arc<GoalData<Self>> {
+        Arc::new(goal)
+    }
+
+    fn goal_data(goal: &Arc<GoalData<Self>>) -> &GoalData<Self> {
+        goal
+    }
+
+    fn intern_substitution<E>(
+        data: impl IntoIterator<Item = Result<Parameter<Self>, E>>,
+    ) -> Result<Vec<Parameter<Self>>, E> {
+        data.into_iter().collect()
+    }
+
+    fn substitution_data(substitution: &Vec<Parameter<Self>>) -> &[Parameter<Self>] {
+        substitution
+    }
 }
 
 impl chalk_ir::family::HasTypeFamily for TypeFamily {
@@ -114,17 +134,21 @@ impl ToChalk for Ty {
         match self {
             Ty::Apply(apply_ty) => {
                 let name = apply_ty.ctor.to_chalk(db);
-                let parameters = apply_ty.parameters.to_chalk(db);
-                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
+                let substitution = apply_ty.parameters.to_chalk(db);
+                chalk_ir::ApplicationTy { name, substitution }.cast().intern()
             }
             Ty::Projection(proj_ty) => {
                 let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
-                let parameters = proj_ty.parameters.to_chalk(db);
-                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern()
+                let substitution = proj_ty.parameters.to_chalk(db);
+                chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern()
             }
-            Ty::Param { idx, .. } => {
-                PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }
-                    .to_ty::<TypeFamily>()
+            Ty::Param(id) => {
+                let interned_id = db.intern_type_param_id(id);
+                PlaceholderIndex {
+                    ui: UniverseIndex::ROOT,
+                    idx: interned_id.as_intern_id().as_usize(),
+                }
+                .to_ty::<TypeFamily>()
             }
             Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
             Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
@@ -135,23 +159,13 @@ impl ToChalk for Ty {
                     .cloned()
                     .map(|p| p.to_chalk(db))
                     .collect();
-                let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) };
+                let bounded_ty = chalk_ir::DynTy { bounds: make_binders(where_clauses, 1) };
                 chalk_ir::TyData::Dyn(bounded_ty).intern()
             }
-            Ty::Opaque(predicates) => {
-                let where_clauses = predicates
-                    .iter()
-                    .filter(|p| !p.is_error())
-                    .cloned()
-                    .map(|p| p.to_chalk(db))
-                    .collect();
-                let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) };
-                chalk_ir::TyData::Opaque(bounded_ty).intern()
-            }
-            Ty::Unknown => {
-                let parameters = Vec::new();
+            Ty::Opaque(_) | Ty::Unknown => {
+                let substitution = chalk_ir::Substitution::empty();
                 let name = TypeName::Error;
-                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
+                chalk_ir::ApplicationTy { name, substitution }.cast().intern()
             }
         }
     }
@@ -161,20 +175,23 @@ impl ToChalk for Ty {
                 TypeName::Error => Ty::Unknown,
                 _ => {
                     let ctor = from_chalk(db, apply_ty.name);
-                    let parameters = from_chalk(db, apply_ty.parameters);
+                    let parameters = from_chalk(db, apply_ty.substitution);
                     Ty::Apply(ApplicationTy { ctor, parameters })
                 }
             },
             chalk_ir::TyData::Placeholder(idx) => {
                 assert_eq!(idx.ui, UniverseIndex::ROOT);
-                Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
+                let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
+                    crate::salsa::InternId::from(idx.idx),
+                );
+                Ty::Param(db.lookup_intern_type_param_id(interned_id))
             }
-            chalk_ir::TyData::Projection(proj) => {
+            chalk_ir::TyData::Alias(proj) => {
                 let associated_ty = from_chalk(db, proj.associated_ty_id);
-                let parameters = from_chalk(db, proj.parameters);
+                let parameters = from_chalk(db, proj.substitution);
                 Ty::Projection(ProjectionTy { associated_ty, parameters })
             }
-            chalk_ir::TyData::ForAll(_) => unimplemented!(),
+            chalk_ir::TyData::Function(_) => unimplemented!(),
             chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
             chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
             chalk_ir::TyData::Dyn(where_clauses) => {
@@ -183,27 +200,18 @@ impl ToChalk for Ty {
                     where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
                 Ty::Dyn(predicates)
             }
-            chalk_ir::TyData::Opaque(where_clauses) => {
-                assert_eq!(where_clauses.bounds.binders.len(), 1);
-                let predicates =
-                    where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
-                Ty::Opaque(predicates)
-            }
         }
     }
 }
 
 impl ToChalk for Substs {
-    type Chalk = Vec<chalk_ir::Parameter<TypeFamily>>;
+    type Chalk = chalk_ir::Substitution<TypeFamily>;
 
-    fn to_chalk(self, db: &impl HirDatabase) -> Vec<Parameter<TypeFamily>> {
-        self.iter().map(|ty| ty.clone().to_chalk(db).cast()).collect()
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Substitution<TypeFamily> {
+        chalk_ir::Substitution::from(self.iter().map(|ty| ty.clone().to_chalk(db)))
     }
 
-    fn from_chalk(
-        db: &impl HirDatabase,
-        parameters: Vec<chalk_ir::Parameter<TypeFamily>>,
-    ) -> Substs {
+    fn from_chalk(db: &impl HirDatabase, parameters: chalk_ir::Substitution<TypeFamily>) -> Substs {
         let tys = parameters
             .into_iter()
             .map(|p| match p.ty() {
@@ -220,13 +228,13 @@ impl ToChalk for TraitRef {
 
     fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef<TypeFamily> {
         let trait_id = self.trait_.to_chalk(db);
-        let parameters = self.substs.to_chalk(db);
-        chalk_ir::TraitRef { trait_id, parameters }
+        let substitution = self.substs.to_chalk(db);
+        chalk_ir::TraitRef { trait_id, substitution }
     }
 
     fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef<TypeFamily>) -> Self {
         let trait_ = from_chalk(db, trait_ref.trait_id);
-        let substs = from_chalk(db, trait_ref.parameters);
+        let substs = from_chalk(db, trait_ref.substitution);
         TraitRef { trait_, substs }
     }
 }
@@ -317,8 +325,8 @@ impl ToChalk for GenericPredicate {
                 make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0)
             }
             GenericPredicate::Projection(projection_pred) => make_binders(
-                chalk_ir::WhereClause::ProjectionEq(chalk_ir::ProjectionEq {
-                    projection: projection_pred.projection_ty.to_chalk(db),
+                chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq {
+                    alias: projection_pred.projection_ty.to_chalk(db),
                     ty: projection_pred.ty.to_chalk(db),
                 }),
                 0,
@@ -335,8 +343,8 @@ impl ToChalk for GenericPredicate {
             chalk_ir::WhereClause::Implemented(tr) => {
                 GenericPredicate::Implemented(from_chalk(db, tr))
             }
-            chalk_ir::WhereClause::ProjectionEq(projection_eq) => {
-                let projection_ty = from_chalk(db, projection_eq.projection);
+            chalk_ir::WhereClause::AliasEq(projection_eq) => {
+                let projection_ty = from_chalk(db, projection_eq.alias);
                 let ty = from_chalk(db, projection_eq.ty);
                 GenericPredicate::Projection(super::ProjectionPredicate { projection_ty, ty })
             }
@@ -345,22 +353,22 @@ impl ToChalk for GenericPredicate {
 }
 
 impl ToChalk for ProjectionTy {
-    type Chalk = chalk_ir::ProjectionTy<TypeFamily>;
+    type Chalk = chalk_ir::AliasTy<TypeFamily>;
 
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ProjectionTy<TypeFamily> {
-        chalk_ir::ProjectionTy {
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::AliasTy<TypeFamily> {
+        chalk_ir::AliasTy {
             associated_ty_id: self.associated_ty.to_chalk(db),
-            parameters: self.parameters.to_chalk(db),
+            substitution: self.parameters.to_chalk(db),
         }
     }
 
     fn from_chalk(
         db: &impl HirDatabase,
-        projection_ty: chalk_ir::ProjectionTy<TypeFamily>,
+        projection_ty: chalk_ir::AliasTy<TypeFamily>,
     ) -> ProjectionTy {
         ProjectionTy {
             associated_ty: from_chalk(db, projection_ty.associated_ty_id),
-            parameters: from_chalk(db, projection_ty.parameters),
+            parameters: from_chalk(db, projection_ty.substitution),
         }
     }
 }
@@ -369,10 +377,7 @@ impl ToChalk for super::ProjectionPredicate {
     type Chalk = chalk_ir::Normalize<TypeFamily>;
 
     fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize<TypeFamily> {
-        chalk_ir::Normalize {
-            projection: self.projection_ty.to_chalk(db),
-            ty: self.ty.to_chalk(db),
-        }
+        chalk_ir::Normalize { alias: self.projection_ty.to_chalk(db), ty: self.ty.to_chalk(db) }
     }
 
     fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize<TypeFamily>) -> Self {
@@ -522,7 +527,7 @@ fn convert_where_clauses(
     let generic_predicates = db.generic_predicates(def);
     let mut result = Vec::with_capacity(generic_predicates.len());
     for pred in generic_predicates.iter() {
-        if pred.is_error() {
+        if pred.value.is_error() {
             // skip errored predicates completely
             continue;
         }
@@ -711,12 +716,12 @@ fn impl_block_datum(
     let trait_ref = db
         .impl_trait(impl_id)
         // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
-        .expect("invalid impl passed to Chalk");
+        .expect("invalid impl passed to Chalk")
+        .value;
     let impl_data = db.impl_data(impl_id);
 
     let generic_params = generics(db, impl_id.into());
     let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = trait_ref.subst(&bound_vars);
     let trait_ = trait_ref.trait_;
     let impl_type = if impl_id.lookup(db).container.module(db).krate == krate {
         chalk_rust_ir::ImplType::Local
@@ -791,20 +796,18 @@ fn type_alias_associated_ty_value(
         _ => panic!("assoc ty value should be in impl"),
     };
 
-    let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist"); // we don't return any assoc ty values if the impl'd trait can't be resolved
+    let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist").value; // we don't return any assoc ty values if the impl'd trait can't be resolved
 
     let assoc_ty = db
         .trait_data(trait_ref.trait_)
         .associated_type_by_name(&type_alias_data.name)
         .expect("assoc ty value should not exist"); // validated when building the impl data as well
-    let generic_params = generics(db, impl_id.into());
-    let bound_vars = Substs::bound_vars(&generic_params);
-    let ty = db.ty(type_alias.into()).subst(&bound_vars);
-    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
+    let ty = db.ty(type_alias.into());
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) };
     let value = chalk_rust_ir::AssociatedTyValue {
         impl_id: Impl::ImplBlock(impl_id.into()).to_chalk(db),
         associated_ty_id: assoc_ty.to_chalk(db),
-        value: make_binders(value_bound, bound_vars.len()),
+        value: make_binders(value_bound, ty.num_binders),
     };
     Arc::new(value)
 }
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index 0b1806a84..508ae9046 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -2,10 +2,11 @@
 //! query, but can't be computed directly from `*Data` (ie, which need a `db`).
 use std::sync::Arc;
 
+use hir_def::generics::WherePredicateTarget;
 use hir_def::{
     adt::VariantData,
     db::DefDatabase,
-    generics::{GenericParams, TypeParamData},
+    generics::{GenericParams, TypeParamData, TypeParamProvenance},
     path::Path,
     resolver::{HasResolver, TypeNs},
     type_ref::TypeRef,
@@ -19,11 +20,18 @@ fn direct_super_traits(db: &impl DefDatabase, trait_: TraitId) -> Vec<TraitId> {
     // lifetime problems, but since there usually shouldn't be more than a
     // few direct traits this should be fine (we could even use some kind of
     // SmallVec if performance is a concern)
-    db.generic_params(trait_.into())
+    let generic_params = db.generic_params(trait_.into());
+    let trait_self = generic_params.find_trait_self_param();
+    generic_params
         .where_predicates
         .iter()
-        .filter_map(|pred| match &pred.type_ref {
-            TypeRef::Path(p) if p == &Path::from(name![Self]) => pred.bound.as_path(),
+        .filter_map(|pred| match &pred.target {
+            WherePredicateTarget::TypeRef(TypeRef::Path(p)) if p == &Path::from(name![Self]) => {
+                pred.bound.as_path()
+            }
+            WherePredicateTarget::TypeParam(local_id) if Some(*local_id) == trait_self => {
+                pred.bound.as_path()
+            }
             _ => None,
         })
         .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path.mod_path()) {
@@ -95,41 +103,77 @@ pub(crate) struct Generics {
 }
 
 impl Generics {
-    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (u32, &'a TypeParamData)> + 'a {
+    pub(crate) fn iter<'a>(
+        &'a self,
+    ) -> impl Iterator<Item = (TypeParamId, &'a TypeParamData)> + 'a {
         self.parent_generics
             .as_ref()
             .into_iter()
-            .flat_map(|it| it.params.types.iter())
-            .chain(self.params.types.iter())
-            .enumerate()
-            .map(|(i, (_local_id, p))| (i as u32, p))
+            .flat_map(|it| {
+                it.params
+                    .types
+                    .iter()
+                    .map(move |(local_id, p)| (TypeParamId { parent: it.def, local_id }, p))
+            })
+            .chain(
+                self.params
+                    .types
+                    .iter()
+                    .map(move |(local_id, p)| (TypeParamId { parent: self.def, local_id }, p)),
+            )
     }
 
-    pub(crate) fn iter_parent<'a>(&'a self) -> impl Iterator<Item = (u32, &'a TypeParamData)> + 'a {
-        self.parent_generics
-            .as_ref()
-            .into_iter()
-            .flat_map(|it| it.params.types.iter())
-            .enumerate()
-            .map(|(i, (_local_id, p))| (i as u32, p))
+    pub(crate) fn iter_parent<'a>(
+        &'a self,
+    ) -> impl Iterator<Item = (TypeParamId, &'a TypeParamData)> + 'a {
+        self.parent_generics.as_ref().into_iter().flat_map(|it| {
+            it.params
+                .types
+                .iter()
+                .map(move |(local_id, p)| (TypeParamId { parent: it.def, local_id }, p))
+        })
     }
 
     pub(crate) fn len(&self) -> usize {
         self.len_split().0
     }
+
     /// (total, parents, child)
     pub(crate) fn len_split(&self) -> (usize, usize, usize) {
         let parent = self.parent_generics.as_ref().map_or(0, |p| p.len());
         let child = self.params.types.len();
         (parent + child, parent, child)
     }
-    pub(crate) fn param_idx(&self, param: TypeParamId) -> u32 {
-        self.find_param(param).0
+
+    /// (parent total, self param, type param list, impl trait)
+    pub(crate) fn provenance_split(&self) -> (usize, usize, usize, usize) {
+        let parent = self.parent_generics.as_ref().map_or(0, |p| p.len());
+        let self_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::TraitSelf)
+            .count();
+        let list_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::TypeParamList)
+            .count();
+        let impl_trait_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::ArgumentImplTrait)
+            .count();
+        (parent, self_params, list_params, impl_trait_params)
     }
-    pub(crate) fn param_name(&self, param: TypeParamId) -> Name {
-        self.find_param(param).1.name.clone()
+
+    pub(crate) fn param_idx(&self, param: TypeParamId) -> Option<u32> {
+        Some(self.find_param(param)?.0)
     }
-    fn find_param(&self, param: TypeParamId) -> (u32, &TypeParamData) {
+
+    fn find_param(&self, param: TypeParamId) -> Option<(u32, &TypeParamData)> {
         if param.parent == self.def {
             let (idx, (_local_id, data)) = self
                 .params
@@ -139,9 +183,10 @@ impl Generics {
                 .find(|(_, (idx, _))| *idx == param.local_id)
                 .unwrap();
             let (_total, parent_len, _child) = self.len_split();
-            return ((parent_len + idx) as u32, data);
+            Some(((parent_len + idx) as u32, data))
+        } else {
+            self.parent_generics.as_ref().and_then(|g| g.find_param(param))
         }
-        self.parent_generics.as_ref().unwrap().find_param(param)
     }
 }
 
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 2c9f9dce0..9ace35229 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -28,6 +28,7 @@ once_cell = "1.2.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_db = { path = "../ra_db" }
+ra_ide_db = { path = "../ra_ide_db" }
 ra_cfg = { path = "../ra_cfg" }
 ra_fmt = { path = "../ra_fmt" }
 ra_prof = { path = "../ra_prof" }
@@ -39,7 +40,7 @@ ra_assists = { path = "../ra_assists" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 
 [dev-dependencies]
-insta = "0.12.0"
+insta = "0.13.0"
 
 [dev-dependencies.proptest]
 version = "0.9.0"
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
index a936900da..40d56a4f7 100644
--- a/crates/ra_ide/src/assists.rs
+++ b/crates/ra_ide/src/assists.rs
@@ -1,22 +1,23 @@
 //! FIXME: write short doc here
 
+use ra_assists::{resolved_assists, AssistAction, AssistLabel};
 use ra_db::{FilePosition, FileRange};
+use ra_ide_db::RootDatabase;
 
-use crate::{db::RootDatabase, FileId, SourceChange, SourceFileEdit};
+use crate::{FileId, SourceChange, SourceFileEdit};
 
-use either::Either;
 pub use ra_assists::AssistId;
-use ra_assists::{AssistAction, AssistLabel};
 
 #[derive(Debug)]
 pub struct Assist {
     pub id: AssistId,
     pub label: String,
-    pub change_data: Either<SourceChange, Vec<SourceChange>>,
+    pub group_label: Option<String>,
+    pub source_change: SourceChange,
 }
 
 pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
-    ra_assists::assists(db, frange)
+    resolved_assists(db, frange)
         .into_iter()
         .map(|assist| {
             let file_id = frange.file_id;
@@ -24,17 +25,8 @@ pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
             Assist {
                 id: assist_label.id,
                 label: assist_label.label.clone(),
-                change_data: match assist.action_data {
-                    Either::Left(action) => {
-                        Either::Left(action_to_edit(action, file_id, assist_label))
-                    }
-                    Either::Right(actions) => Either::Right(
-                        actions
-                            .into_iter()
-                            .map(|action| action_to_edit(action, file_id, assist_label))
-                            .collect(),
-                    ),
-                },
+                group_label: assist.group_label.map(|it| it.0),
+                source_change: action_to_edit(assist.action, file_id, assist_label),
             }
         })
         .collect()
@@ -46,9 +38,6 @@ fn action_to_edit(
     assist_label: &AssistLabel,
 ) -> SourceChange {
     let file_edit = SourceFileEdit { file_id, edit: action.edit };
-    SourceChange::source_file_edit(
-        action.label.unwrap_or_else(|| assist_label.label.clone()),
-        file_edit,
-    )
-    .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
+    SourceChange::source_file_edit(assist_label.label.clone(), file_edit)
+        .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
 }
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index aa5d60c7b..f984f40ad 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -3,6 +3,7 @@
 use indexmap::IndexMap;
 
 use hir::db::AstDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, DocCommentsOwner},
     match_ast, AstNode, TextRange,
@@ -10,7 +11,6 @@ use ra_syntax::{
 
 use crate::{
     call_info::FnCallNode,
-    db::RootDatabase,
     display::{ShortLabel, ToNav},
     expand::descend_into_macros,
     goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 72a68522e..f2b29306e 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -1,15 +1,13 @@
 //! FIXME: write short doc here
 use hir::db::AstDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, ArgListOwner},
     match_ast, AstNode, SyntaxNode,
 };
-
 use test_utils::tested_by;
 
-use crate::{
-    db::RootDatabase, expand::descend_into_macros, CallInfo, FilePosition, FunctionSignature,
-};
+use crate::{expand::descend_into_macros, CallInfo, FilePosition, FunctionSignature};
 
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index ad7f6ef26..4f24cd1f9 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -18,6 +18,7 @@ mod complete_macro_in_item_position;
 mod complete_trait_impl;
 
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 
 #[cfg(test)]
 use crate::completion::completion_item::do_completion;
@@ -26,7 +27,7 @@ use crate::{
         completion_context::CompletionContext,
         completion_item::{CompletionKind, Completions},
     },
-    db, FilePosition,
+    FilePosition,
 };
 
 pub use crate::completion::completion_item::{
@@ -55,7 +56,7 @@ pub use crate::completion::completion_item::{
 /// `foo` *should* be present among the completion variants. Filtering by
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
-pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Option<Completions> {
+pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<Completions> {
     let original_parse = db.parse(position.file_id);
     let ctx = CompletionContext::new(db, &original_parse, position)?;
 
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 458d7525e..e2ee86dd1 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -1,11 +1,6 @@
 //! FIXME: write short doc here
 
-use ra_assists::auto_import_text_edit;
-use ra_syntax::{ast, AstNode, SmolStr};
-use ra_text_edit::TextEditBuilder;
-use rustc_hash::FxHashMap;
-
-use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
+use crate::completion::{CompletionContext, Completions};
 
 pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_trivial_path {
@@ -15,120 +10,14 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
         acc.add_resolution(ctx, name.to_string(), &res)
     });
-
-    // auto-import
-    // We fetch ident from the original file, because we need to pre-filter auto-imports
-    if ast::NameRef::cast(ctx.token.parent()).is_some() {
-        let import_resolver = ImportResolver::new();
-        let import_names = import_resolver.all_names(ctx.token.text());
-        import_names.into_iter().for_each(|(name, path)| {
-            let edit = {
-                let mut builder = TextEditBuilder::default();
-                builder.replace(ctx.source_range(), name.to_string());
-                auto_import_text_edit(
-                    &ctx.token.parent(),
-                    &ctx.token.parent(),
-                    &path,
-                    &mut builder,
-                );
-                builder.finish()
-            };
-
-            // Hack: copied this check form conv.rs beacause auto import can produce edits
-            // that invalidate assert in conv_with.
-            if edit
-                .as_atoms()
-                .iter()
-                .filter(|atom| !ctx.source_range().is_subrange(&atom.delete))
-                .all(|atom| ctx.source_range().intersection(&atom.delete).is_none())
-            {
-                CompletionItem::new(
-                    CompletionKind::Reference,
-                    ctx.source_range(),
-                    build_import_label(&name, &path),
-                )
-                .text_edit(edit)
-                .add_to(acc);
-            }
-        });
-    }
-}
-
-fn build_import_label(name: &str, path: &[SmolStr]) -> String {
-    let mut buf = String::with_capacity(64);
-    buf.push_str(name);
-    buf.push_str(" (");
-    fmt_import_path(path, &mut buf);
-    buf.push_str(")");
-    buf
-}
-
-fn fmt_import_path(path: &[SmolStr], buf: &mut String) {
-    let mut segments = path.iter();
-    if let Some(s) = segments.next() {
-        buf.push_str(&s);
-    }
-    for s in segments {
-        buf.push_str("::");
-        buf.push_str(&s);
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub(crate) struct ImportResolver {
-    // todo: use fst crate or something like that
-    dummy_names: Vec<(SmolStr, Vec<SmolStr>)>,
-}
-
-impl ImportResolver {
-    pub(crate) fn new() -> Self {
-        let dummy_names = vec![
-            (SmolStr::new("fmt"), vec![SmolStr::new("std"), SmolStr::new("fmt")]),
-            (SmolStr::new("io"), vec![SmolStr::new("std"), SmolStr::new("io")]),
-            (SmolStr::new("iter"), vec![SmolStr::new("std"), SmolStr::new("iter")]),
-            (SmolStr::new("hash"), vec![SmolStr::new("std"), SmolStr::new("hash")]),
-            (
-                SmolStr::new("Debug"),
-                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Debug")],
-            ),
-            (
-                SmolStr::new("Display"),
-                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Display")],
-            ),
-            (
-                SmolStr::new("Hash"),
-                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hash")],
-            ),
-            (
-                SmolStr::new("Hasher"),
-                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hasher")],
-            ),
-            (
-                SmolStr::new("Iterator"),
-                vec![SmolStr::new("std"), SmolStr::new("iter"), SmolStr::new("Iterator")],
-            ),
-        ];
-
-        ImportResolver { dummy_names }
-    }
-
-    // Returns a map of importable items filtered by name.
-    // The map associates item name with its full path.
-    // todo: should return Resolutions
-    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, Vec<SmolStr>> {
-        if name.len() > 1 {
-            self.dummy_names.iter().filter(|(n, _)| n.contains(name)).cloned().collect()
-        } else {
-            FxHashMap::default()
-        }
-    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
     use insta::assert_debug_snapshot;
 
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+
     fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
         do_completion(code, CompletionKind::Reference)
     }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 528655fbc..0175f5e55 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -2,7 +2,7 @@ use crate::completion::{CompletionContext, Completions, CompletionItem, Completi
 
 use ra_syntax::ast::{self, NameOwner, AstNode};
 
-use hir::{self, db::HirDatabase};
+use hir::{self, db::HirDatabase, Docs};
 
 
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 18c91a840..8678a3234 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -1,5 +1,6 @@
 //! FIXME: write short doc here
 
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{find_covering_element, find_node_at_offset},
     ast, AstNode, Parse, SourceFile,
@@ -8,13 +9,13 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
 
-use crate::{db, FilePosition};
+use crate::FilePosition;
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
 pub(crate) struct CompletionContext<'a> {
-    pub(super) db: &'a db::RootDatabase,
+    pub(super) db: &'a RootDatabase,
     pub(super) analyzer: hir::SourceAnalyzer,
     pub(super) offset: TextUnit,
     pub(super) token: SyntaxToken,
@@ -49,7 +50,7 @@ pub(crate) struct CompletionContext<'a> {
 
 impl<'a> CompletionContext<'a> {
     pub(super) fn new(
-        db: &'a db::RootDatabase,
+        db: &'a RootDatabase,
         original_parse: &'a Parse<ast::SourceFile>,
         position: FilePosition,
     ) -> Option<CompletionContext<'a>> {
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index f403b3bcf..22bd49723 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -5,6 +5,7 @@ use std::cell::RefCell;
 use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
 use itertools::Itertools;
 use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     algo,
@@ -13,7 +14,7 @@ use ra_syntax::{
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 
-use crate::{db::RootDatabase, Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit};
+use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit};
 
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index 1e4a472b4..c23e08e9a 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -4,13 +4,11 @@ use std::fmt::{self, Display};
 
 use hir::{Docs, Documentation, HasSource, HirDisplay};
 use join_to_string::join;
+use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode, NameOwner, VisibilityOwner};
 use std::convert::From;
 
-use crate::{
-    db,
-    display::{generic_parameters, where_predicates},
-};
+use crate::display::{generic_parameters, where_predicates};
 
 #[derive(Debug)]
 pub enum CallableKind {
@@ -48,13 +46,13 @@ impl FunctionSignature {
         self
     }
 
-    pub(crate) fn from_hir(db: &db::RootDatabase, function: hir::Function) -> Self {
+    pub(crate) fn from_hir(db: &RootDatabase, function: hir::Function) -> Self {
         let doc = function.docs(db);
         let ast_node = function.source(db).value;
         FunctionSignature::from(&ast_node).with_doc_opt(doc)
     }
 
-    pub(crate) fn from_struct(db: &db::RootDatabase, st: hir::Struct) -> Option<Self> {
+    pub(crate) fn from_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
         let node: ast::StructDef = st.source(db).value;
         match node.kind() {
             ast::StructKind::Record(_) => return None,
@@ -86,10 +84,7 @@ impl FunctionSignature {
         )
     }
 
-    pub(crate) fn from_enum_variant(
-        db: &db::RootDatabase,
-        variant: hir::EnumVariant,
-    ) -> Option<Self> {
+    pub(crate) fn from_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
         let node: ast::EnumVariant = variant.source(db).value;
         match node.kind() {
             ast::StructKind::Record(_) | ast::StructKind::Unit => return None,
@@ -126,7 +121,7 @@ impl FunctionSignature {
         )
     }
 
-    pub(crate) fn from_macro(db: &db::RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
+    pub(crate) fn from_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
         let node: ast::MacroCall = macro_def.source(db).value;
 
         let params = vec![];
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index b2af3479c..906aab1eb 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -3,6 +3,7 @@
 use either::Either;
 use hir::{AssocItem, FieldSource, HasSource, InFile, ModuleSource};
 use ra_db::{FileId, SourceDatabase};
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, DocCommentsOwner, NameOwner},
     match_ast, AstNode, SmolStr,
@@ -10,7 +11,7 @@ use ra_syntax::{
     TextRange,
 };
 
-use crate::{db::RootDatabase, expand::original_range, FileSymbol};
+use crate::{expand::original_range, FileSymbol};
 
 use super::short_label::ShortLabel;
 
diff --git a/crates/ra_ide/src/expand.rs b/crates/ra_ide/src/expand.rs
index b82259a3d..9f3aaa3a3 100644
--- a/crates/ra_ide/src/expand.rs
+++ b/crates/ra_ide/src/expand.rs
@@ -3,9 +3,10 @@ use std::iter::successors;
 
 use hir::{InFile, Origin};
 use ra_db::FileId;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxToken, TextRange};
 
-use crate::{db::RootDatabase, FileRange};
+use crate::FileRange;
 
 pub(crate) fn original_range(db: &RootDatabase, node: InFile<&SyntaxNode>) -> FileRange {
     if let Some((range, Origin::Call)) = original_range_and_origin(db, node) {
@@ -79,6 +80,14 @@ pub(crate) fn descend_into_macros(
     let source_analyzer =
         hir::SourceAnalyzer::new(db, src.with_value(src.value.parent()).as_ref(), None);
 
+    descend_into_macros_with_analyzer(db, &source_analyzer, src)
+}
+
+pub(crate) fn descend_into_macros_with_analyzer(
+    db: &RootDatabase,
+    source_analyzer: &hir::SourceAnalyzer,
+    src: InFile<SyntaxToken>,
+) -> InFile<SyntaxToken> {
     successors(Some(src), |token| {
         let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
         let tt = macro_call.token_tree()?;
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index 0f7b6e875..af2783bef 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -1,14 +1,15 @@
 //! This modules implements "expand macro" functionality in the IDE
 
-use crate::{db::RootDatabase, FilePosition};
 use hir::db::AstDatabase;
 use ra_db::SourceDatabase;
-use rustc_hash::FxHashMap;
-
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{find_node_at_offset, replace_descendants},
     ast, AstNode, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, WalkEvent, T,
 };
+use rustc_hash::FxHashMap;
+
+use crate::FilePosition;
 
 pub struct ExpandedMacro {
     pub name: String,
@@ -185,7 +186,7 @@ fn some_thing() -> u32 {
         //- /lib.rs
         macro_rules! match_ast {
             (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-        
+
             (match ($node:expr) {
                 $( ast::$ast:ident($it:ident) => $res:block, )*
                 _ => $catch_all:expr $(,)?
@@ -193,7 +194,7 @@ fn some_thing() -> u32 {
                 $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
                 { $catch_all }
             }};
-        }        
+        }
 
         fn main() {
             mat<|>ch_ast! {
@@ -227,11 +228,11 @@ fn some_thing() -> u32 {
             r#"
         //- /lib.rs
         macro_rules! match_ast {
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };        
+            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
             (match ($node:expr) {}) => {{}};
-        }        
+        }
 
-        fn main() {        
+        fn main() {
             let p = f(|it| {
                 let res = mat<|>ch_ast! { match c {}};
                 Some(res)
@@ -254,9 +255,9 @@ fn some_thing() -> u32 {
         }
         macro_rules! foo {
             () => {bar!()};
-        }        
+        }
 
-        fn main() {        
+        fn main() {
             let res = fo<|>o!();
         }
         "#,
@@ -277,9 +278,9 @@ fn some_thing() -> u32 {
         }
         macro_rules! foo {
             () => {$crate::bar!()};
-        }        
+        }
 
-        fn main() {        
+        fn main() {
             let res = fo<|>o!();
         }
         "#,
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index 930e0c4c2..726963a33 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -1,6 +1,10 @@
 //! FIXME: write short doc here
 
+use std::iter::successors;
+
+use hir::db::AstDatabase;
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_covering_element,
     ast::{self, AstNode, AstToken},
@@ -9,9 +13,7 @@ use ra_syntax::{
     SyntaxNode, SyntaxToken, TextRange, TextUnit, TokenAtOffset, T,
 };
 
-use crate::{db::RootDatabase, expand::descend_into_macros, FileId, FileRange};
-use hir::db::AstDatabase;
-use std::iter::successors;
+use crate::{expand::descend_into_macros, FileId, FileRange};
 
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
     let src = db.parse(frange.file_id).tree();
@@ -512,8 +514,8 @@ fn bar(){}
     fn test_extend_trait_bounds_list_in_where_clause() {
         do_check(
             r#"
-fn foo<R>() 
-    where 
+fn foo<R>()
+    where
         R: req::Request + 'static,
         R::Params: DeserializeOwned<|> + panic::UnwindSafe + 'static,
         R::Result: Serialize + 'static,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 5a12a619c..de5551a4c 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 
 use hir::{db::AstDatabase, InFile, SourceBinder};
+use ra_ide_db::{symbol_index, RootDatabase};
 use ra_syntax::{
     ast::{self, DocCommentsOwner},
     match_ast, AstNode,
@@ -9,7 +10,6 @@ use ra_syntax::{
 };
 
 use crate::{
-    db::RootDatabase,
     display::{ShortLabel, ToNav},
     expand::descend_into_macros,
     references::{classify_name_ref, NameKind::*},
@@ -76,11 +76,10 @@ pub(crate) fn reference_definition(
     let name_kind = classify_name_ref(sb, name_ref).map(|d| d.kind);
     match name_kind {
         Some(Macro(it)) => return Exact(it.to_nav(sb.db)),
-        Some(Field(it)) => return Exact(it.to_nav(sb.db)),
+        Some(StructField(it)) => return Exact(it.to_nav(sb.db)),
         Some(TypeParam(it)) => return Exact(it.to_nav(sb.db)),
-        Some(AssocItem(it)) => return Exact(it.to_nav(sb.db)),
         Some(Local(it)) => return Exact(it.to_nav(sb.db)),
-        Some(Def(def)) => match NavigationTarget::from_def(sb.db, def) {
+        Some(ModuleDef(def)) => match NavigationTarget::from_def(sb.db, def) {
             Some(nav) => return Exact(nav),
             None => return Approximate(vec![]),
         },
@@ -94,7 +93,7 @@ pub(crate) fn reference_definition(
     };
 
     // Fallback index based approach:
-    let navs = crate::symbol_index::index_resolve(sb.db, name_ref.value)
+    let navs = symbol_index::index_resolve(sb.db, name_ref.value)
         .into_iter()
         .map(|s| s.to_nav(sb.db))
         .collect();
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index ce8b6c72a..11ad6d137 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -1,11 +1,11 @@
 //! FIXME: write short doc here
 
 use hir::db::AstDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
 
 use crate::{
-    db::RootDatabase, display::ToNav, expand::descend_into_macros, FilePosition, NavigationTarget,
-    RangeInfo,
+    display::ToNav, expand::descend_into_macros, FilePosition, NavigationTarget, RangeInfo,
 };
 
 pub(crate) fn goto_type_definition(
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 6661e5cb2..3f88bb260 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -2,6 +2,7 @@
 
 use hir::{db::AstDatabase, Adt, HasSource, HirDisplay, SourceBinder};
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_covering_element,
     ast::{self, DocCommentsOwner},
@@ -11,7 +12,6 @@ use ra_syntax::{
 };
 
 use crate::{
-    db::RootDatabase,
     display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
     expand::descend_into_macros,
     references::{classify_name, classify_name_ref, NameKind, NameKind::*},
@@ -98,19 +98,14 @@ fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<S
             let src = it.source(db);
             hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)))
         }
-        Field(it) => {
+        StructField(it) => {
             let src = it.source(db);
             match src.value {
                 hir::FieldSource::Named(it) => hover_text(it.doc_comment_text(), it.short_label()),
                 _ => None,
             }
         }
-        AssocItem(it) => match it {
-            hir::AssocItem::Function(it) => from_def_source(db, it),
-            hir::AssocItem::Const(it) => from_def_source(db, it),
-            hir::AssocItem::TypeAlias(it) => from_def_source(db, it),
-        },
-        Def(it) => match it {
+        ModuleDef(it) => match it {
             hir::ModuleDef::Module(it) => match it.definition_source(db).value {
                 hir::ModuleSource::Module(it) => {
                     hover_text(it.doc_comment_text(), it.short_label())
diff --git a/crates/ra_ide/src/impls.rs b/crates/ra_ide/src/impls.rs
index 9834025d3..64a2dadc8 100644
--- a/crates/ra_ide/src/impls.rs
+++ b/crates/ra_ide/src/impls.rs
@@ -2,9 +2,10 @@
 
 use hir::{Crate, ImplBlock, SourceBinder};
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
 
-use crate::{db::RootDatabase, display::ToNav, FilePosition, NavigationTarget, RangeInfo};
+use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
 
 pub(crate) fn goto_implementation(
     db: &RootDatabase,
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 393ca9447..6b0d3d996 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -2,13 +2,14 @@
 
 use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
 use once_cell::unsync::Lazy;
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
     match_ast, SmolStr, SourceFile, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{db::RootDatabase, FileId, FunctionSignature};
+use crate::{FileId, FunctionSignature};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
@@ -376,7 +377,7 @@ fn main() {
     let mut start = 0;
     (0..2).for_each(|increment| {
         start += increment;
-    })
+    });
 
     let multiply = |a, b, c, d| a * b * c * d;
     let _: i32 = multiply(1, 2, 3, 4);
@@ -399,37 +400,37 @@ fn main() {
                 label: "i32",
             },
             InlayHint {
-                range: [114; 122),
+                range: [115; 123),
                 kind: TypeHint,
                 label: "|…| -> i32",
             },
             InlayHint {
-                range: [126; 127),
+                range: [127; 128),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [129; 130),
+                range: [130; 131),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [132; 133),
+                range: [133; 134),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [135; 136),
+                range: [136; 137),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [200; 212),
+                range: [201; 213),
                 kind: TypeHint,
                 label: "&|…| -> i32",
             },
             InlayHint {
-                range: [235; 244),
+                range: [236; 245),
                 kind: TypeHint,
                 label: "|| -> i32",
             },
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 4d8deb21c..689921f3f 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -10,12 +10,8 @@
 // For proving that RootDatabase is RefUnwindSafe.
 #![recursion_limit = "128"]
 
-mod db;
 pub mod mock_analysis;
-mod symbol_index;
-mod change;
 mod source_change;
-mod feature_flags;
 
 mod status;
 mod completion;
@@ -34,14 +30,11 @@ mod assists;
 mod diagnostics;
 mod syntax_tree;
 mod folding_ranges;
-mod line_index;
-mod line_index_utils;
 mod join_lines;
 mod typing;
 mod matching_brace;
 mod display;
 mod inlay_hints;
-mod wasm_shims;
 mod expand;
 mod expand_macro;
 
@@ -57,24 +50,24 @@ use ra_db::{
     salsa::{self, ParallelDatabase},
     CheckCanceled, Env, FileLoader, SourceDatabase,
 };
+use ra_ide_db::{
+    symbol_index::{self, FileSymbol},
+    LineIndexDatabase,
+};
 use ra_syntax::{SourceFile, TextRange, TextUnit};
 
-use crate::{db::LineIndexDatabase, display::ToNav, symbol_index::FileSymbol};
+use crate::display::ToNav;
 
 pub use crate::{
     assists::{Assist, AssistId},
     call_hierarchy::CallItem,
-    change::{AnalysisChange, LibraryData},
     completion::{CompletionItem, CompletionItemKind, InsertTextFormat},
     diagnostics::Severity,
     display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
     expand_macro::ExpandedMacro,
-    feature_flags::FeatureFlags,
     folding_ranges::{Fold, FoldKind},
     hover::HoverResult,
     inlay_hints::{InlayHint, InlayKind},
-    line_index::{LineCol, LineIndex},
-    line_index_utils::translate_offset_with_edit,
     references::{
         Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, SearchScope,
     },
@@ -87,6 +80,14 @@ pub use hir::Documentation;
 pub use ra_db::{
     Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
+pub use ra_ide_db::{
+    change::{AnalysisChange, LibraryData},
+    feature_flags::FeatureFlags,
+    line_index::{LineCol, LineIndex},
+    line_index_utils::translate_offset_with_edit,
+    symbol_index::Query,
+    RootDatabase,
+};
 
 pub type Cancelable<T> = Result<T, Canceled>;
 
@@ -98,46 +99,6 @@ pub struct Diagnostic {
     pub severity: Severity,
 }
 
-#[derive(Debug)]
-pub struct Query {
-    query: String,
-    lowercased: String,
-    only_types: bool,
-    libs: bool,
-    exact: bool,
-    limit: usize,
-}
-
-impl Query {
-    pub fn new(query: String) -> Query {
-        let lowercased = query.to_lowercase();
-        Query {
-            query,
-            lowercased,
-            only_types: false,
-            libs: false,
-            exact: false,
-            limit: usize::max_value(),
-        }
-    }
-
-    pub fn only_types(&mut self) {
-        self.only_types = true;
-    }
-
-    pub fn libs(&mut self) {
-        self.libs = true;
-    }
-
-    pub fn exact(&mut self) {
-        self.exact = true;
-    }
-
-    pub fn limit(&mut self, limit: usize) {
-        self.limit = limit
-    }
-}
-
 /// Info associated with a text range.
 #[derive(Debug)]
 pub struct RangeInfo<T> {
@@ -162,7 +123,7 @@ pub struct CallInfo {
 /// `AnalysisHost` stores the current state of the world.
 #[derive(Debug)]
 pub struct AnalysisHost {
-    db: db::RootDatabase,
+    db: RootDatabase,
 }
 
 impl Default for AnalysisHost {
@@ -173,7 +134,7 @@ impl Default for AnalysisHost {
 
 impl AnalysisHost {
     pub fn new(lru_capcity: Option<usize>, feature_flags: FeatureFlags) -> AnalysisHost {
-        AnalysisHost { db: db::RootDatabase::new(lru_capcity, feature_flags) }
+        AnalysisHost { db: RootDatabase::new(lru_capcity, feature_flags) }
     }
     /// Returns a snapshot of the current state, which you can query for
     /// semantic information.
@@ -202,6 +163,9 @@ impl AnalysisHost {
     pub fn per_query_memory_usage(&mut self) -> Vec<(String, ra_prof::Bytes)> {
         self.db.per_query_memory_usage()
     }
+    pub fn request_cancellation(&mut self) {
+        self.db.request_cancellation();
+    }
     pub fn raw_database(
         &self,
     ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
@@ -220,7 +184,7 @@ impl AnalysisHost {
 /// `Analysis` are canceled (most method return `Err(Canceled)`).
 #[derive(Debug)]
 pub struct Analysis {
-    db: salsa::Snapshot<db::RootDatabase>,
+    db: salsa::Snapshot<RootDatabase>,
 }
 
 // As a general design guideline, `Analysis` API are intended to be independent
@@ -501,7 +465,7 @@ impl Analysis {
     }
 
     /// Performs an operation on that may be Canceled.
-    fn with_db<F: FnOnce(&db::RootDatabase) -> T + std::panic::UnwindSafe, T>(
+    fn with_db<F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe, T>(
         &self,
         f: F,
     ) -> Cancelable<T> {
@@ -514,3 +478,77 @@ fn analysis_is_send() {
     fn is_send<T: Send>() {}
     is_send::<Analysis>();
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{display::NavigationTarget, mock_analysis::single_file, Query};
+    use ra_syntax::{
+        SmolStr,
+        SyntaxKind::{FN_DEF, STRUCT_DEF},
+    };
+
+    #[test]
+    fn test_world_symbols_with_no_container() {
+        let code = r#"
+    enum FooInner { }
+    "#;
+
+        let mut symbols = get_symbols_matching(code, "FooInner");
+
+        let s = symbols.pop().unwrap();
+
+        assert_eq!(s.name(), "FooInner");
+        assert!(s.container_name().is_none());
+    }
+
+    #[test]
+    fn test_world_symbols_include_container_name() {
+        let code = r#"
+fn foo() {
+    enum FooInner { }
+}
+    "#;
+
+        let mut symbols = get_symbols_matching(code, "FooInner");
+
+        let s = symbols.pop().unwrap();
+
+        assert_eq!(s.name(), "FooInner");
+        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
+
+        let code = r#"
+mod foo {
+    struct FooInner;
+}
+    "#;
+
+        let mut symbols = get_symbols_matching(code, "FooInner");
+
+        let s = symbols.pop().unwrap();
+
+        assert_eq!(s.name(), "FooInner");
+        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
+    }
+
+    #[test]
+    fn test_world_symbols_are_case_sensitive() {
+        let code = r#"
+fn foo() {}
+
+struct Foo;
+        "#;
+
+        let symbols = get_symbols_matching(code, "Foo");
+
+        let fn_match = symbols.iter().find(|s| s.name() == "foo").map(|s| s.kind());
+        let struct_match = symbols.iter().find(|s| s.name() == "Foo").map(|s| s.kind());
+
+        assert_eq!(fn_match, Some(FN_DEF));
+        assert_eq!(struct_match, Some(STRUCT_DEF));
+    }
+
+    fn get_symbols_matching(text: &str, query: &str) -> Vec<NavigationTarget> {
+        let (analysis, _) = single_file(text);
+        analysis.symbol_search(Query::new(query.into())).unwrap()
+    }
+}
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
index 077a44473..5bf4d2062 100644
--- a/crates/ra_ide/src/marks.rs
+++ b/crates/ra_ide/src/marks.rs
@@ -11,4 +11,5 @@ test_utils::marks!(
     call_info_bad_offset
     dont_complete_current_use
     dont_complete_primitive_in_use
+    test_resolve_parent_module_on_module_decl
 );
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index bf8a54932..081aaee8c 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
-use ra_db::{Env, RelativePathBuf};
+use ra_db::{CrateName, Env, RelativePathBuf};
 use test_utils::{extract_offset, extract_range, parse_fixture, CURSOR_MARKER};
 
 use crate::{
@@ -107,7 +107,9 @@ impl MockAnalysis {
                     crate_graph.add_crate_root(file_id, Edition2018, cfg_options, Env::default());
                 let crate_name = path.parent().unwrap().file_name().unwrap();
                 if let Some(root_crate) = root_crate {
-                    crate_graph.add_dep(root_crate, crate_name.into(), other_crate).unwrap();
+                    crate_graph
+                        .add_dep(root_crate, CrateName::new(crate_name).unwrap(), other_crate)
+                        .unwrap();
                 }
             }
             change.add_file(source_root, file_id, path, Arc::new(contents));
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index 2dbccfc3b..af14d6ab3 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -1,19 +1,35 @@
 //! FIXME: write short doc here
 
 use ra_db::{CrateId, FileId, FilePosition, SourceDatabase};
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_node_at_offset,
     ast::{self, AstNode},
 };
+use test_utils::tested_by;
 
-use crate::{db::RootDatabase, NavigationTarget};
+use crate::NavigationTarget;
 
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
 pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
     let mut sb = hir::SourceBinder::new(db);
     let parse = db.parse(position.file_id);
-    let module = match find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
+
+    let mut module = find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset);
+
+    // If cursor is literally on `mod foo`, go to the grandpa.
+    if let Some(m) = &module {
+        if !m
+            .item_list()
+            .map_or(false, |it| it.syntax().text_range().contains_inclusive(position.offset))
+        {
+            tested_by!(test_resolve_parent_module_on_module_decl);
+            module = m.syntax().ancestors().skip(1).find_map(ast::Module::cast);
+        }
+    }
+
+    let module = match module {
         Some(module) => sb.to_def(hir::InFile::new(position.file_id.into(), module)),
         None => sb.to_module_def(position.file_id),
     };
@@ -40,6 +56,7 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
 mod tests {
     use ra_cfg::CfgOptions;
     use ra_db::Env;
+    use test_utils::covers;
 
     use crate::{
         mock_analysis::{analysis_and_position, MockAnalysis},
@@ -62,6 +79,25 @@ mod tests {
     }
 
     #[test]
+    fn test_resolve_parent_module_on_module_decl() {
+        covers!(test_resolve_parent_module_on_module_decl);
+        let (analysis, pos) = analysis_and_position(
+            "
+            //- /lib.rs
+            mod foo;
+
+            //- /foo.rs
+            mod <|>bar;
+
+            //- /foo/bar.rs
+            // empty
+            ",
+        );
+        let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
+        nav.assert_match("foo MODULE FileId(1) [0; 8)");
+    }
+
+    #[test]
     fn test_resolve_parent_module_for_inline() {
         let (analysis, pos) = analysis_and_position(
             "
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 5e2fe1905..a6320bd2f 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -10,13 +10,13 @@
 //! resolved to the search element definition, we get a reference.
 
 mod classify;
-mod name_definition;
 mod rename;
 mod search_scope;
 
 use hir::{InFile, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     algo::find_node_at_offset,
@@ -24,15 +24,13 @@ use ra_syntax::{
     match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, TextUnit, TokenAtOffset,
 };
 
-use crate::{
-    db::RootDatabase, display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo,
-};
+use crate::{display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 
 pub(crate) use self::{
     classify::{classify_name, classify_name_ref},
-    name_definition::{NameDefinition, NameKind},
     rename::rename,
 };
+pub(crate) use ra_ide_db::defs::{NameDefinition, NameKind};
 
 pub use self::search_scope::SearchScope;
 
@@ -112,38 +110,32 @@ impl IntoIterator for ReferenceSearchResult {
 
 pub(crate) fn find_all_refs(
     db: &RootDatabase,
-    mut position: FilePosition,
+    position: FilePosition,
     search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
 
-    let token = syntax.token_at_offset(position.offset);
-    let mut search_kind = ReferenceKind::Other;
+    let (opt_name, search_kind) =
+        if let Some(name) = get_struct_def_name_for_struc_litetal_search(&syntax, position) {
+            (Some(name), ReferenceKind::StructLiteral)
+        } else {
+            (find_node_at_offset::<ast::Name>(&syntax, position.offset), ReferenceKind::Other)
+        };
 
-    if let TokenAtOffset::Between(ref left, ref right) = token {
-        if (right.kind() == SyntaxKind::L_CURLY || right.kind() == SyntaxKind::L_PAREN)
-            && left.kind() != SyntaxKind::IDENT
-        {
-            position = FilePosition { offset: left.text_range().start(), ..position };
-            search_kind = ReferenceKind::StructLiteral;
-        }
-    }
-
-    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
+    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position, opt_name)?;
 
     let declaration = match def.kind {
         NameKind::Macro(mac) => mac.to_nav(db),
-        NameKind::Field(field) => field.to_nav(db),
-        NameKind::AssocItem(assoc) => assoc.to_nav(db),
-        NameKind::Def(def) => NavigationTarget::from_def(db, def)?,
+        NameKind::StructField(field) => field.to_nav(db),
+        NameKind::ModuleDef(def) => NavigationTarget::from_def(db, def)?,
         NameKind::SelfType(imp) => imp.to_nav(db),
         NameKind::Local(local) => local.to_nav(db),
         NameKind::TypeParam(_) => return None,
     };
 
     let search_scope = {
-        let base = def.search_scope(db);
+        let base = SearchScope::for_def(&def, db);
         match search_scope {
             None => base,
             Some(scope) => base.intersection(&scope),
@@ -170,9 +162,10 @@ fn find_name(
     db: &RootDatabase,
     syntax: &SyntaxNode,
     position: FilePosition,
+    opt_name: Option<ast::Name>,
 ) -> Option<RangeInfo<(String, NameDefinition)>> {
     let mut sb = SourceBinder::new(db);
-    if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
+    if let Some(name) = opt_name {
         let def = classify_name(&mut sb, InFile::new(position.file_id.into(), &name))?;
         let range = name.syntax().text_range();
         return Some(RangeInfo::new(range, (name.text().to_string(), def)));
@@ -218,15 +211,8 @@ fn process_definition(
                 if let Some(d) = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
                 {
                     if d == def {
-                        let kind = if name_ref
-                            .syntax()
-                            .ancestors()
-                            .find_map(ast::RecordLit::cast)
-                            .and_then(|l| l.path())
-                            .and_then(|p| p.segment())
-                            .and_then(|p| p.name_ref())
-                            .map(|n| n == name_ref)
-                            .unwrap_or(false)
+                        let kind = if is_record_lit_name_ref(&name_ref)
+                            || is_call_expr_name_ref(&name_ref)
                         {
                             ReferenceKind::StructLiteral
                         } else {
@@ -253,7 +239,7 @@ fn decl_access(
     range: TextRange,
 ) -> Option<ReferenceAccess> {
     match kind {
-        NameKind::Local(_) | NameKind::Field(_) => {}
+        NameKind::Local(_) | NameKind::StructField(_) => {}
         _ => return None,
     };
 
@@ -273,7 +259,7 @@ fn decl_access(
 fn reference_access(kind: &NameKind, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
     // Only Locals and Fields have accesses for now.
     match kind {
-        NameKind::Local(_) | NameKind::Field(_) => {}
+        NameKind::Local(_) | NameKind::StructField(_) => {}
         _ => return None,
     };
 
@@ -301,6 +287,49 @@ fn reference_access(kind: &NameKind, name_ref: &ast::NameRef) -> Option<Referenc
     mode.or(Some(ReferenceAccess::Read))
 }
 
+fn is_record_lit_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::RecordLit::cast)
+        .and_then(|l| l.path())
+        .and_then(|p| p.segment())
+        .map(|p| p.name_ref().as_ref() == Some(name_ref))
+        .unwrap_or(false)
+}
+
+fn get_struct_def_name_for_struc_litetal_search(
+    syntax: &SyntaxNode,
+    position: FilePosition,
+) -> Option<ast::Name> {
+    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
+        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+            return None;
+        }
+        if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, left.text_range().start()) {
+            return name.syntax().ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
+        }
+        if find_node_at_offset::<ast::TypeParamList>(&syntax, left.text_range().start()).is_some() {
+            return left.ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
+        }
+    }
+    None
+}
+
+fn is_call_expr_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::CallExpr::cast)
+        .and_then(|c| match c.expr()? {
+            ast::Expr::PathExpr(p) => {
+                Some(p.path()?.segment()?.name_ref().as_ref() == Some(name_ref))
+            }
+            _ => None,
+        })
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
@@ -309,7 +338,7 @@ mod tests {
     };
 
     #[test]
-    fn test_struct_literal() {
+    fn test_struct_literal_after_space() {
         let code = r#"
     struct Foo <|>{
         a: i32,
@@ -331,6 +360,58 @@ mod tests {
     }
 
     #[test]
+    fn test_struct_literal_befor_space() {
+        let code = r#"
+    struct Foo<|> {}
+        fn main() {
+        let f: Foo;
+        f = Foo {};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 18) [12; 15) Other",
+            &["FileId(1) [54; 57) Other", "FileId(1) [71; 74) StructLiteral"],
+        );
+    }
+
+    #[test]
+    fn test_struct_literal_with_generic_type() {
+        let code = r#"
+    struct Foo<T> <|>{}
+        fn main() {
+        let f: Foo::<i32>;
+        f = Foo {};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 21) [12; 15) Other",
+            &["FileId(1) [81; 84) StructLiteral"],
+        );
+    }
+
+    #[test]
+    fn test_struct_literal_for_tuple() {
+        let code = r#"
+    struct Foo<|>(i32);
+
+    fn main() {
+        let f: Foo;
+        f = Foo(1);
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 21) [12; 15) Other",
+            &["FileId(1) [71; 74) StructLiteral"],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_for_local() {
         let code = r#"
     fn main() {
@@ -564,7 +645,7 @@ mod tests {
         check_result(
             refs,
             "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
-            &["FileId(2) [16; 20) Other", "FileId(3) [16; 20) Other"],
+            &["FileId(2) [16; 20) StructLiteral", "FileId(3) [16; 20) StructLiteral"],
         );
 
         let refs =
@@ -572,7 +653,7 @@ mod tests {
         check_result(
             refs,
             "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
-            &["FileId(3) [16; 20) Other"],
+            &["FileId(3) [16; 20) StructLiteral"],
         );
     }
 
@@ -591,7 +672,7 @@ mod tests {
         check_result(
             refs,
             "m1 MACRO_CALL FileId(1) [9; 63) [46; 48) Other",
-            &["FileId(1) [96; 98) Other", "FileId(1) [114; 116) Other"],
+            &["FileId(1) [96; 98) StructLiteral", "FileId(1) [114; 116) StructLiteral"],
         );
     }
 
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 46cba30a3..d0f03d8a8 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -2,119 +2,13 @@
 
 use hir::{InFile, PathResolution, SourceBinder};
 use ra_prof::profile;
-use ra_syntax::{ast, match_ast, AstNode};
+use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
 
-use super::{
-    name_definition::{from_assoc_item, from_module_def, from_struct_field},
-    NameDefinition, NameKind,
-};
-use crate::db::RootDatabase;
+use super::{NameDefinition, NameKind};
+use ra_ide_db::RootDatabase;
 
-pub(crate) fn classify_name(
-    sb: &mut SourceBinder<RootDatabase>,
-    name: InFile<&ast::Name>,
-) -> Option<NameDefinition> {
-    let _p = profile("classify_name");
-    let parent = name.value.syntax().parent()?;
-
-    match_ast! {
-        match parent {
-            ast::BindPat(it) => {
-                let src = name.with_value(it);
-                let local = sb.to_def(src)?;
-                Some(NameDefinition {
-                    visibility: None,
-                    container: local.module(sb.db),
-                    kind: NameKind::Local(local),
-                })
-            },
-            ast::RecordFieldDef(it) => {
-                let src = name.with_value(it);
-                let field: hir::StructField = sb.to_def(src)?;
-                Some(from_struct_field(sb.db, field))
-            },
-            ast::Module(it) => {
-                let def = sb.to_def(name.with_value(it))?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::StructDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Struct = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::EnumDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Enum = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::TraitDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Trait = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::StaticDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Static = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::EnumVariant(it) => {
-                let src = name.with_value(it);
-                let def: hir::EnumVariant = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
-            },
-            ast::FnDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Function = sb.to_def(src)?;
-                if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(sb.db, def.into()))
-                } else {
-                    Some(from_module_def(sb.db, def.into(), None))
-                }
-            },
-            ast::ConstDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Const = sb.to_def(src)?;
-                if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(sb.db, def.into()))
-                } else {
-                    Some(from_module_def(sb.db, def.into(), None))
-                }
-            },
-            ast::TypeAliasDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::TypeAlias = sb.to_def(src)?;
-                if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(sb.db, def.into()))
-                } else {
-                    Some(from_module_def(sb.db, def.into(), None))
-                }
-            },
-            ast::MacroCall(it) => {
-                let src = name.with_value(it);
-                let def = sb.to_def(src.clone())?;
-
-                let module = sb.to_module_def(src.file_id.original_file(sb.db))?;
-
-                Some(NameDefinition {
-                    visibility: None,
-                    container: module,
-                    kind: NameKind::Macro(def),
-                })
-            },
-            ast::TypeParam(it) => {
-                let src = name.with_value(it);
-                let def = sb.to_def(src)?;
-                Some(NameDefinition {
-                    visibility: None,
-                    container: def.module(sb.db),
-                    kind: NameKind::TypeParam(def),
-                })
-            },
-            _ => None,
-        }
-    }
-}
+pub use ra_ide_db::defs::{classify_name, from_module_def, from_struct_field};
 
 pub(crate) fn classify_name_ref(
     sb: &mut SourceBinder<RootDatabase>,
@@ -128,7 +22,7 @@ pub(crate) fn classify_name_ref(
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
         if let Some(func) = analyzer.resolve_method_call(&method_call) {
-            return Some(from_assoc_item(sb.db, func.into()));
+            return Some(from_module_def(sb.db, func.into(), None));
         }
     }
 
@@ -163,27 +57,35 @@ pub(crate) fn classify_name_ref(
 
     let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = analyzer.resolve_path(sb.db, &path)?;
-    match resolved {
-        PathResolution::Def(def) => Some(from_module_def(sb.db, def, Some(container))),
-        PathResolution::AssocItem(item) => Some(from_assoc_item(sb.db, item)),
+    let res = match resolved {
+        PathResolution::Def(def) => from_module_def(sb.db, def, Some(container)),
+        PathResolution::AssocItem(item) => {
+            let def = match item {
+                hir::AssocItem::Function(it) => it.into(),
+                hir::AssocItem::Const(it) => it.into(),
+                hir::AssocItem::TypeAlias(it) => it.into(),
+            };
+            from_module_def(sb.db, def, Some(container))
+        }
         PathResolution::Local(local) => {
             let kind = NameKind::Local(local);
             let container = local.module(sb.db);
-            Some(NameDefinition { kind, container, visibility: None })
+            NameDefinition { kind, container, visibility: None }
         }
         PathResolution::TypeParam(par) => {
             let kind = NameKind::TypeParam(par);
             let container = par.module(sb.db);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
         PathResolution::Macro(def) => {
             let kind = NameKind::Macro(def);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
         PathResolution::SelfType(impl_block) => {
             let kind = NameKind::SelfType(impl_block);
             let container = impl_block.module(sb.db);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
-    }
+    };
+    Some(res)
 }
diff --git a/crates/ra_ide/src/references/name_definition.rs b/crates/ra_ide/src/references/name_definition.rs
deleted file mode 100644
index 1e4226ab9..000000000
--- a/crates/ra_ide/src/references/name_definition.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-//! `NameDefinition` keeps information about the element we want to search references for.
-//! The element is represented by `NameKind`. It's located inside some `container` and
-//! has a `visibility`, which defines a search scope.
-//! Note that the reference search is possible for not all of the classified items.
-
-use hir::{
-    Adt, AssocItem, HasSource, ImplBlock, Local, MacroDef, Module, ModuleDef, StructField,
-    TypeParam, VariantDef,
-};
-use ra_syntax::{ast, ast::VisibilityOwner};
-
-use crate::db::RootDatabase;
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum NameKind {
-    Macro(MacroDef),
-    Field(StructField),
-    AssocItem(AssocItem),
-    Def(ModuleDef),
-    SelfType(ImplBlock),
-    Local(Local),
-    TypeParam(TypeParam),
-}
-
-#[derive(PartialEq, Eq)]
-pub(crate) struct NameDefinition {
-    pub visibility: Option<ast::Visibility>,
-    /// FIXME: this doesn't really make sense. For example, builtin types don't
-    /// really have a module.
-    pub container: Module,
-    pub kind: NameKind,
-}
-
-pub(super) fn from_assoc_item(db: &RootDatabase, item: AssocItem) -> NameDefinition {
-    let container = item.module(db);
-    let visibility = match item {
-        AssocItem::Function(f) => f.source(db).value.visibility(),
-        AssocItem::Const(c) => c.source(db).value.visibility(),
-        AssocItem::TypeAlias(a) => a.source(db).value.visibility(),
-    };
-    let kind = NameKind::AssocItem(item);
-    NameDefinition { kind, container, visibility }
-}
-
-pub(super) fn from_struct_field(db: &RootDatabase, field: StructField) -> NameDefinition {
-    let kind = NameKind::Field(field);
-    let parent = field.parent_def(db);
-    let container = parent.module(db);
-    let visibility = match parent {
-        VariantDef::Struct(s) => s.source(db).value.visibility(),
-        VariantDef::Union(e) => e.source(db).value.visibility(),
-        VariantDef::EnumVariant(e) => e.source(db).value.parent_enum().visibility(),
-    };
-    NameDefinition { kind, container, visibility }
-}
-
-pub(super) fn from_module_def(
-    db: &RootDatabase,
-    def: ModuleDef,
-    module: Option<Module>,
-) -> NameDefinition {
-    let kind = NameKind::Def(def);
-    let (container, visibility) = match def {
-        ModuleDef::Module(it) => {
-            let container = it.parent(db).or_else(|| Some(it)).unwrap();
-            let visibility = it.declaration_source(db).and_then(|s| s.value.visibility());
-            (container, visibility)
-        }
-        ModuleDef::EnumVariant(it) => {
-            let container = it.module(db);
-            let visibility = it.source(db).value.parent_enum().visibility();
-            (container, visibility)
-        }
-        ModuleDef::Function(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Const(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Static(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Trait(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::BuiltinType(..) => (module.unwrap(), None),
-    };
-    NameDefinition { kind, container, visibility }
-}
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 626efb603..08e77c01f 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -2,12 +2,14 @@
 
 use hir::ModuleSource;
 use ra_db::{RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt};
-use ra_syntax::{algo::find_node_at_offset, ast, tokenize, AstNode, SyntaxKind, SyntaxNode};
+use ra_ide_db::RootDatabase;
+use ra_syntax::{
+    algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
+};
 use ra_text_edit::TextEdit;
 
 use crate::{
-    db::RootDatabase, FileId, FilePosition, FileSystemEdit, RangeInfo, SourceChange,
-    SourceFileEdit, TextRange,
+    FileId, FilePosition, FileSystemEdit, RangeInfo, SourceChange, SourceFileEdit, TextRange,
 };
 
 use super::find_all_refs;
@@ -17,11 +19,9 @@ pub(crate) fn rename(
     position: FilePosition,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let tokens = tokenize(new_name);
-    if tokens.len() != 1
-        || (tokens[0].kind != SyntaxKind::IDENT && tokens[0].kind != SyntaxKind::UNDERSCORE)
-    {
-        return None;
+    match lex_single_valid_syntax_kind(new_name)? {
+        SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
+        _ => return None,
     }
 
     let parse = db.parse(position.file_id);
diff --git a/crates/ra_ide/src/references/search_scope.rs b/crates/ra_ide/src/references/search_scope.rs
index f8211a746..279f57be0 100644
--- a/crates/ra_ide/src/references/search_scope.rs
+++ b/crates/ra_ide/src/references/search_scope.rs
@@ -10,7 +10,7 @@ use ra_prof::profile;
 use ra_syntax::{AstNode, TextRange};
 use rustc_hash::FxHashMap;
 
-use crate::db::RootDatabase;
+use ra_ide_db::RootDatabase;
 
 use super::{NameDefinition, NameKind};
 
@@ -19,59 +19,13 @@ pub struct SearchScope {
 }
 
 impl SearchScope {
-    fn new(entries: FxHashMap<FileId, Option<TextRange>>) -> SearchScope {
-        SearchScope { entries }
-    }
-    pub fn single_file(file: FileId) -> SearchScope {
-        SearchScope::new(std::iter::once((file, None)).collect())
-    }
-    pub(crate) fn intersection(&self, other: &SearchScope) -> SearchScope {
-        let (mut small, mut large) = (&self.entries, &other.entries);
-        if small.len() > large.len() {
-            mem::swap(&mut small, &mut large)
-        }
-
-        let res = small
-            .iter()
-            .filter_map(|(file_id, r1)| {
-                let r2 = large.get(file_id)?;
-                let r = intersect_ranges(*r1, *r2)?;
-                Some((*file_id, r))
-            })
-            .collect();
-        return SearchScope::new(res);
-
-        fn intersect_ranges(
-            r1: Option<TextRange>,
-            r2: Option<TextRange>,
-        ) -> Option<Option<TextRange>> {
-            match (r1, r2) {
-                (None, r) | (r, None) => Some(r),
-                (Some(r1), Some(r2)) => {
-                    let r = r1.intersection(&r2)?;
-                    Some(Some(r))
-                }
-            }
-        }
-    }
-}
-
-impl IntoIterator for SearchScope {
-    type Item = (FileId, Option<TextRange>);
-    type IntoIter = std::collections::hash_map::IntoIter<FileId, Option<TextRange>>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.entries.into_iter()
-    }
-}
-
-impl NameDefinition {
-    pub(crate) fn search_scope(&self, db: &RootDatabase) -> SearchScope {
+    pub(crate) fn for_def(def: &NameDefinition, db: &RootDatabase) -> SearchScope {
         let _p = profile("search_scope");
 
-        let module_src = self.container.definition_source(db);
+        let module_src = def.container.definition_source(db);
         let file_id = module_src.file_id.original_file(db);
 
-        if let NameKind::Local(var) = self.kind {
+        if let NameKind::Local(var) = def.kind {
             let range = match var.parent(db) {
                 DefWithBody::Function(f) => f.source(db).value.syntax().text_range(),
                 DefWithBody::Const(c) => c.source(db).value.syntax().text_range(),
@@ -82,10 +36,10 @@ impl NameDefinition {
             return SearchScope::new(res);
         }
 
-        let vis = self.visibility.as_ref().map(|v| v.syntax().to_string()).unwrap_or_default();
+        let vis = def.visibility.as_ref().map(|v| v.syntax().to_string()).unwrap_or_default();
 
         if vis.as_str() == "pub(super)" {
-            if let Some(parent_module) = self.container.parent(db) {
+            if let Some(parent_module) = def.container.parent(db) {
                 let mut res = FxHashMap::default();
                 let parent_src = parent_module.definition_source(db);
                 let file_id = parent_src.file_id.original_file(db);
@@ -118,7 +72,7 @@ impl NameDefinition {
                 return SearchScope::new(res);
             }
             if vis.as_str() == "pub" {
-                let krate = self.container.krate();
+                let krate = def.container.krate();
                 for rev_dep in krate.reverse_dependencies(db) {
                     let root_file = rev_dep.root_file(db);
                     let source_root_id = db.file_source_root(root_file);
@@ -137,4 +91,48 @@ impl NameDefinition {
         res.insert(file_id, range);
         SearchScope::new(res)
     }
+
+    fn new(entries: FxHashMap<FileId, Option<TextRange>>) -> SearchScope {
+        SearchScope { entries }
+    }
+    pub fn single_file(file: FileId) -> SearchScope {
+        SearchScope::new(std::iter::once((file, None)).collect())
+    }
+    pub(crate) fn intersection(&self, other: &SearchScope) -> SearchScope {
+        let (mut small, mut large) = (&self.entries, &other.entries);
+        if small.len() > large.len() {
+            mem::swap(&mut small, &mut large)
+        }
+
+        let res = small
+            .iter()
+            .filter_map(|(file_id, r1)| {
+                let r2 = large.get(file_id)?;
+                let r = intersect_ranges(*r1, *r2)?;
+                Some((*file_id, r))
+            })
+            .collect();
+        return SearchScope::new(res);
+
+        fn intersect_ranges(
+            r1: Option<TextRange>,
+            r2: Option<TextRange>,
+        ) -> Option<Option<TextRange>> {
+            match (r1, r2) {
+                (None, r) | (r, None) => Some(r),
+                (Some(r1), Some(r2)) => {
+                    let r = r1.intersection(&r2)?;
+                    Some(Some(r))
+                }
+            }
+        }
+    }
+}
+
+impl IntoIterator for SearchScope {
+    type Item = (FileId, Option<TextRange>);
+    type IntoIter = std::collections::hash_map::IntoIter<FileId, Option<TextRange>>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.entries.into_iter()
+    }
 }
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index 7533692f6..b6b0c70f9 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -3,12 +3,13 @@
 use hir::InFile;
 use itertools::Itertools;
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner, ModuleItemOwner, NameOwner},
     match_ast, SyntaxNode, TextRange,
 };
 
-use crate::{db::RootDatabase, FileId};
+use crate::FileId;
 
 #[derive(Debug)]
 pub struct Runnable {
@@ -43,7 +44,7 @@ fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
     let name = fn_def.name()?.text().clone();
     let kind = if name == "main" {
         RunnableKind::Bin
-    } else if fn_def.has_atom_attr("test") {
+    } else if has_test_related_attribute(&fn_def) {
         RunnableKind::Test { name: name.to_string() }
     } else if fn_def.has_atom_attr("bench") {
         RunnableKind::Bench { name: name.to_string() }
@@ -53,6 +54,20 @@ fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
     Some(Runnable { range: fn_def.syntax().text_range(), kind })
 }
 
+/// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
+/// `#[test_case(...)]`, `#[tokio::test]` and similar.
+/// Also a regular `#[test]` annotation is supported.
+///
+/// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
+/// but it's better than not to have the runnables for the tests at all.
+fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
+    fn_def
+        .attrs()
+        .filter_map(|attr| attr.path())
+        .map(|path| path.syntax().to_string().to_lowercase())
+        .any(|attribute_text| attribute_text.contains("test"))
+}
+
 fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Option<Runnable> {
     let has_test_function = module
         .item_list()?
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 1d130544f..1cc55e78b 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -34,6 +34,16 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="function">foo</span>::&lt;<span class="type.builtin">i32</span>&gt;();
 }
 
+<span class="macro">macro_rules</span><span class="macro">!</span> def_fn {
+    ($($tt:tt)*) =&gt; {$($tt)*}
+}
+
+<span class="macro">def_fn</span><span class="macro">!</span>{
+    <span class="keyword">fn</span> <span class="function">bar</span>() -&gt; <span class="type.builtin">u32</span> {
+        <span class="literal.numeric">100</span>
+    }
+}
+
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function">main</span>() {
     <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal.numeric">92</span>);
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index d90ee8540..918fd4b97 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -24,14 +24,14 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .keyword\.control  { color: #F0DFAF; font-weight: bold; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span> = <span class="string">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="14702933417323009544" style="color: hsl(108,90%,49%);">x</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="5443150872754369068" style="color: hsl(215,43%,43%);">y</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="4303609361109701698" style="color: hsl(242,75%,88%);">x</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="13865792086344377029" style="color: hsl(340,64%,86%);">y</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
 
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span> = <span class="string">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="2073121142529774969" style="color: hsl(320,43%,74%);">y</span> = <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span> = <span class="string">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="12461245066629867975" style="color: hsl(132,91%,68%);">y</span> = <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span>.to_string();
 }
 
 <span class="keyword">fn</span> <span class="function">bar</span>() {
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
 }</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/status.rs b/crates/ra_ide/src/status.rs
index 1bb27eb85..30eb5c995 100644
--- a/crates/ra_ide/src/status.rs
+++ b/crates/ra_ide/src/status.rs
@@ -10,14 +10,14 @@ use ra_db::{
     },
     FileTextQuery, SourceRootId,
 };
+use ra_ide_db::{
+    symbol_index::{LibrarySymbolsQuery, SymbolIndex},
+    RootDatabase,
+};
 use ra_prof::{memory_usage, Bytes};
 use ra_syntax::{ast, Parse, SyntaxNode};
 
-use crate::{
-    db::RootDatabase,
-    symbol_index::{LibrarySymbolsQuery, SymbolIndex},
-    FileId,
-};
+use crate::FileId;
 
 fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
     db.query(ra_db::ParseQuery).entries::<SyntaxTreeStats>()
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 0411977b9..174e13595 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -1,14 +1,18 @@
 //! FIXME: write short doc here
 
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 
-use hir::{InFile, Name, SourceBinder};
+use hir::{HirFileId, InFile, Name, SourceAnalyzer, SourceBinder};
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
-use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T};
+use ra_syntax::{
+    ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken, TextRange,
+    WalkEvent, T,
+};
 
 use crate::{
-    db::RootDatabase,
+    expand::descend_into_macros_with_analyzer,
     references::{
         classify_name, classify_name_ref,
         NameKind::{self, *},
@@ -72,121 +76,186 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
     let parse = db.parse(file_id);
     let root = parse.tree().syntax().clone();
 
-    fn calc_binding_hash(file_id: FileId, name: &Name, shadow_count: u32) -> u64 {
-        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
-            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+    let mut sb = SourceBinder::new(db);
+    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
+    let mut res = Vec::new();
+    let analyzer = sb.analyze(InFile::new(file_id.into(), &root), None);
 
-            let mut hasher = DefaultHasher::new();
-            x.hash(&mut hasher);
-            hasher.finish()
+    let mut in_macro_call = None;
+
+    for event in root.preorder_with_tokens() {
+        match event {
+            WalkEvent::Enter(node) => match node.kind() {
+                MACRO_CALL => {
+                    in_macro_call = Some(node.clone());
+                    if let Some(range) = highlight_macro(InFile::new(file_id.into(), node)) {
+                        res.push(HighlightedRange { range, tag: tags::MACRO, binding_hash: None });
+                    }
+                }
+                _ if in_macro_call.is_some() => {
+                    if let Some(token) = node.as_token() {
+                        if let Some((tag, binding_hash)) = highlight_token_tree(
+                            db,
+                            &mut sb,
+                            &analyzer,
+                            &mut bindings_shadow_count,
+                            InFile::new(file_id.into(), token.clone()),
+                        ) {
+                            res.push(HighlightedRange {
+                                range: node.text_range(),
+                                tag,
+                                binding_hash,
+                            });
+                        }
+                    }
+                }
+                _ => {
+                    if let Some((tag, binding_hash)) = highlight_node(
+                        db,
+                        &mut sb,
+                        &mut bindings_shadow_count,
+                        InFile::new(file_id.into(), node.clone()),
+                    ) {
+                        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash });
+                    }
+                }
+            },
+            WalkEvent::Leave(node) => {
+                if let Some(m) = in_macro_call.as_ref() {
+                    if *m == node {
+                        in_macro_call = None;
+                    }
+                }
+            }
         }
+    }
 
-        hash((file_id, name, shadow_count))
+    res
+}
+
+fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
+    let macro_call = ast::MacroCall::cast(node.value.as_node()?.clone())?;
+    let path = macro_call.path()?;
+    let name_ref = path.segment()?.name_ref()?;
+
+    let range_start = name_ref.syntax().text_range().start();
+    let mut range_end = name_ref.syntax().text_range().end();
+    for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
+        match sibling.kind() {
+            T![!] | IDENT => range_end = sibling.text_range().end(),
+            _ => (),
+        }
     }
 
-    let mut sb = SourceBinder::new(db);
+    Some(TextRange::from_to(range_start, range_end))
+}
 
-    // Visited nodes to handle highlighting priorities
-    // FIXME: retain only ranges here
-    let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default();
-    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
+fn highlight_token_tree(
+    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
+    analyzer: &SourceAnalyzer,
+    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    token: InFile<SyntaxToken>,
+) -> Option<(&'static str, Option<u64>)> {
+    if token.value.parent().kind() != TOKEN_TREE {
+        return None;
+    }
+    let token = descend_into_macros_with_analyzer(db, analyzer, token);
+    let expanded = {
+        let parent = token.value.parent();
+        // We only care Name and Name_ref
+        match (token.value.kind(), parent.kind()) {
+            (IDENT, NAME) | (IDENT, NAME_REF) => token.with_value(parent.into()),
+            _ => token.map(|it| it.into()),
+        }
+    };
 
-    let mut res = Vec::new();
-    for node in root.descendants_with_tokens() {
-        if highlighted.contains(&node) {
-            continue;
+    highlight_node(db, sb, bindings_shadow_count, expanded)
+}
+
+fn highlight_node(
+    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
+    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    node: InFile<SyntaxElement>,
+) -> Option<(&'static str, Option<u64>)> {
+    let mut binding_hash = None;
+    let tag = match node.value.kind() {
+        FN_DEF => {
+            bindings_shadow_count.clear();
+            return None;
         }
-        let mut binding_hash = None;
-        let tag = match node.kind() {
-            FN_DEF => {
-                bindings_shadow_count.clear();
-                continue;
-            }
-            COMMENT => tags::LITERAL_COMMENT,
-            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
-            ATTR => tags::LITERAL_ATTRIBUTE,
-            // Special-case field init shorthand
-            NAME_REF if node.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
-            NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue,
-            NAME_REF => {
-                let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-                let name_kind = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
-                    .map(|d| d.kind);
-                match name_kind {
-                    Some(name_kind) => {
-                        if let Local(local) = &name_kind {
-                            if let Some(name) = local.name(db) {
-                                let shadow_count =
-                                    bindings_shadow_count.entry(name.clone()).or_default();
-                                binding_hash =
-                                    Some(calc_binding_hash(file_id, &name, *shadow_count))
-                            }
-                        };
-
-                        highlight_name(db, name_kind)
-                    }
-                    _ => continue,
-                }
-            }
-            NAME => {
-                let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
-                let name_kind =
-                    classify_name(&mut sb, InFile::new(file_id.into(), &name)).map(|d| d.kind);
-
-                if let Some(Local(local)) = &name_kind {
-                    if let Some(name) = local.name(db) {
-                        let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
-                        *shadow_count += 1;
-                        binding_hash = Some(calc_binding_hash(file_id, &name, *shadow_count))
-                    }
-                };
-
-                match name_kind {
-                    Some(name_kind) => highlight_name(db, name_kind),
-                    None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
-                        STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
-                        TYPE_PARAM => tags::TYPE_PARAM,
-                        RECORD_FIELD_DEF => tags::FIELD,
-                        _ => tags::FUNCTION,
-                    }),
+        COMMENT => tags::LITERAL_COMMENT,
+        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
+        ATTR => tags::LITERAL_ATTRIBUTE,
+        // Special-case field init shorthand
+        NAME_REF if node.value.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
+        NAME_REF if node.value.ancestors().any(|it| it.kind() == ATTR) => return None,
+        NAME_REF => {
+            let name_ref = node.value.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
+            let name_kind = classify_name_ref(sb, node.with_value(&name_ref)).map(|d| d.kind);
+            match name_kind {
+                Some(name_kind) => {
+                    if let Local(local) = &name_kind {
+                        if let Some(name) = local.name(db) {
+                            let shadow_count =
+                                bindings_shadow_count.entry(name.clone()).or_default();
+                            binding_hash =
+                                Some(calc_binding_hash(node.file_id, &name, *shadow_count))
+                        }
+                    };
+
+                    highlight_name(db, name_kind)
                 }
+                _ => return None,
             }
-            INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
-            BYTE => tags::LITERAL_BYTE,
-            CHAR => tags::LITERAL_CHAR,
-            LIFETIME => tags::TYPE_LIFETIME,
-            T![unsafe] => tags::KEYWORD_UNSAFE,
-            k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
-            k if k.is_keyword() => tags::KEYWORD,
-            _ => {
-                if let Some(macro_call) = node.as_node().cloned().and_then(ast::MacroCall::cast) {
-                    if let Some(path) = macro_call.path() {
-                        if let Some(segment) = path.segment() {
-                            if let Some(name_ref) = segment.name_ref() {
-                                highlighted.insert(name_ref.syntax().clone().into());
-                                let range_start = name_ref.syntax().text_range().start();
-                                let mut range_end = name_ref.syntax().text_range().end();
-                                for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
-                                    match sibling.kind() {
-                                        T![!] | IDENT => range_end = sibling.text_range().end(),
-                                        _ => (),
-                                    }
-                                }
-                                res.push(HighlightedRange {
-                                    range: TextRange::from_to(range_start, range_end),
-                                    tag: tags::MACRO,
-                                    binding_hash: None,
-                                })
-                            }
-                        }
-                    }
+        }
+        NAME => {
+            let name = node.value.as_node().cloned().and_then(ast::Name::cast).unwrap();
+            let name_kind = classify_name(sb, node.with_value(&name)).map(|d| d.kind);
+
+            if let Some(Local(local)) = &name_kind {
+                if let Some(name) = local.name(db) {
+                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
+                    *shadow_count += 1;
+                    binding_hash = Some(calc_binding_hash(node.file_id, &name, *shadow_count))
                 }
-                continue;
+            };
+
+            match name_kind {
+                Some(name_kind) => highlight_name(db, name_kind),
+                None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
+                    STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
+                    TYPE_PARAM => tags::TYPE_PARAM,
+                    RECORD_FIELD_DEF => tags::FIELD,
+                    _ => tags::FUNCTION,
+                }),
             }
-        };
-        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash })
+        }
+        INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
+        BYTE => tags::LITERAL_BYTE,
+        CHAR => tags::LITERAL_CHAR,
+        LIFETIME => tags::TYPE_LIFETIME,
+        T![unsafe] => tags::KEYWORD_UNSAFE,
+        k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
+        k if k.is_keyword() => tags::KEYWORD,
+
+        _ => return None,
+    };
+
+    return Some((tag, binding_hash));
+
+    fn calc_binding_hash(file_id: HirFileId, name: &Name, shadow_count: u32) -> u64 {
+        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
+            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+
+            let mut hasher = DefaultHasher::new();
+            x.hash(&mut hasher);
+            hasher.finish()
+        }
+
+        hash((file_id, name, shadow_count))
     }
-    res
 }
 
 pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
@@ -251,19 +320,16 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
 fn highlight_name(db: &RootDatabase, name_kind: NameKind) -> &'static str {
     match name_kind {
         Macro(_) => tags::MACRO,
-        Field(_) => tags::FIELD,
-        AssocItem(hir::AssocItem::Function(_)) => tags::FUNCTION,
-        AssocItem(hir::AssocItem::Const(_)) => tags::CONSTANT,
-        AssocItem(hir::AssocItem::TypeAlias(_)) => tags::TYPE,
-        Def(hir::ModuleDef::Module(_)) => tags::MODULE,
-        Def(hir::ModuleDef::Function(_)) => tags::FUNCTION,
-        Def(hir::ModuleDef::Adt(_)) => tags::TYPE,
-        Def(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Const(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Static(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Trait(_)) => tags::TYPE,
-        Def(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
-        Def(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
+        StructField(_) => tags::FIELD,
+        ModuleDef(hir::ModuleDef::Module(_)) => tags::MODULE,
+        ModuleDef(hir::ModuleDef::Function(_)) => tags::FUNCTION,
+        ModuleDef(hir::ModuleDef::Adt(_)) => tags::TYPE,
+        ModuleDef(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
+        ModuleDef(hir::ModuleDef::Const(_)) => tags::CONSTANT,
+        ModuleDef(hir::ModuleDef::Static(_)) => tags::CONSTANT,
+        ModuleDef(hir::ModuleDef::Trait(_)) => tags::TYPE,
+        ModuleDef(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
+        ModuleDef(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
         SelfType(_) => tags::TYPE_SELF,
         TypeParam(_) => tags::TYPE_PARAM,
         Local(local) => {
@@ -331,6 +397,16 @@ fn foo<T>() -> T {
     foo::<i32>();
 }
 
+macro_rules! def_fn {
+    ($($tt:tt)*) => {$($tt)*}
+}
+
+def_fn!{
+    fn bar() -> u32 {
+        100
+    }
+}
+
 // comment
 fn main() {
     println!("Hello, {}!", 92);
diff --git a/crates/ra_ide/src/syntax_tree.rs b/crates/ra_ide/src/syntax_tree.rs
index 4d0f0fc47..55966daf3 100644
--- a/crates/ra_ide/src/syntax_tree.rs
+++ b/crates/ra_ide/src/syntax_tree.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
-use crate::db::RootDatabase;
 use ra_db::SourceDatabase;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo, AstNode, NodeOrToken, SourceFile,
     SyntaxKind::{RAW_STRING, STRING},
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 21e5be9b3..e5d1779fd 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -15,6 +15,7 @@
 
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_node_at_offset,
     ast::{self, AstToken},
@@ -24,7 +25,7 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEdit;
 
-use crate::{db::RootDatabase, source_change::SingleFileChange, SourceChange, SourceFileEdit};
+use crate::{source_change::SingleFileChange, SourceChange, SourceFileEdit};
 
 pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<SourceChange> {
     let parse = db.parse(position.file_id);
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
new file mode 100644
index 000000000..716e88bc1
--- /dev/null
+++ b/crates/ra_ide_db/Cargo.toml
@@ -0,0 +1,47 @@
+[package]
+edition = "2018"
+name = "ra_ide_db"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+
+[lib]
+doctest = false
+
+[features]
+wasm = []
+
+[dependencies]
+either = "1.5"
+format-buf = "1.0.0"
+indexmap = "1.3.0"
+itertools = "0.8.0"
+join_to_string = "0.1.3"
+log = "0.4.5"
+rayon = "1.0.2"
+fst = { version = "0.3.1", default-features = false }
+rustc-hash = "1.0"
+unicase = "2.2.0"
+superslice = "1.0.0"
+rand = { version = "0.7.0", features = ["small_rng"] }
+once_cell = "1.2.0"
+
+ra_syntax = { path = "../ra_syntax" }
+ra_text_edit = { path = "../ra_text_edit" }
+ra_db = { path = "../ra_db" }
+ra_cfg = { path = "../ra_cfg" }
+ra_fmt = { path = "../ra_fmt" }
+ra_prof = { path = "../ra_prof" }
+test_utils = { path = "../test_utils" }
+
+# ra_ide should depend only on the top-level `hir` package. if you need
+# something from some `hir_xxx` subpackage, reexport the API via `hir`.
+hir = { path = "../ra_hir", package = "ra_hir" }
+
+[dev-dependencies]
+insta = "0.13.0"
+
+[dev-dependencies.proptest]
+version = "0.9.0"
+# Disable `fork` feature to allow compiling on webassembly
+default-features = false
+features = ["std", "bit-set", "break-dead-code"]
diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide_db/src/change.rs
index b0aa2c8e0..4668784d3 100644
--- a/crates/ra_ide/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! Defines a unit of change that can applied to a state of IDE to get the next
+//! state. Changes are transactional.
 
 use std::{fmt, sync::Arc, time};
 
@@ -14,8 +15,8 @@ use rayon::prelude::*;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    db::{DebugData, RootDatabase},
     symbol_index::{SymbolIndex, SymbolsDatabase},
+    DebugData, RootDatabase,
 };
 
 #[derive(Default)]
@@ -145,6 +146,8 @@ impl LibraryData {
         root_id: SourceRootId,
         files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
     ) -> LibraryData {
+        let _p = profile("LibraryData::prepare");
+
         #[cfg(not(feature = "wasm"))]
         let iter = files.par_iter();
         #[cfg(feature = "wasm")]
@@ -166,13 +169,15 @@ impl LibraryData {
 const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
 
 impl RootDatabase {
-    pub(crate) fn apply_change(&mut self, change: AnalysisChange) {
+    pub fn request_cancellation(&mut self) {
+        let _p = profile("RootDatabase::request_cancellation");
+        self.salsa_runtime_mut().synthetic_write(Durability::LOW);
+    }
+
+    pub fn apply_change(&mut self, change: AnalysisChange) {
         let _p = profile("RootDatabase::apply_change");
+        self.request_cancellation();
         log::info!("apply_change {:?}", change);
-        {
-            let _p = profile("RootDatabase::apply_change/cancellation");
-            self.salsa_runtime_mut().synthetic_write(Durability::LOW);
-        }
         if !change.new_roots.is_empty() {
             let mut local_roots = Vec::clone(&self.local_roots());
             for (root_id, is_local) in change.new_roots {
@@ -241,7 +246,7 @@ impl RootDatabase {
         self.set_source_root_with_durability(root_id, Arc::new(source_root), durability);
     }
 
-    pub(crate) fn maybe_collect_garbage(&mut self) {
+    pub fn maybe_collect_garbage(&mut self) {
         if cfg!(feature = "wasm") {
             return;
         }
@@ -251,7 +256,7 @@ impl RootDatabase {
         }
     }
 
-    pub(crate) fn collect_garbage(&mut self) {
+    pub fn collect_garbage(&mut self) {
         if cfg!(feature = "wasm") {
             return;
         }
@@ -278,7 +283,7 @@ impl RootDatabase {
         self.query(hir::db::BodyQuery).sweep(sweep);
     }
 
-    pub(crate) fn per_query_memory_usage(&mut self) -> Vec<(String, Bytes)> {
+    pub fn per_query_memory_usage(&mut self) -> Vec<(String, Bytes)> {
         let mut acc: Vec<(String, Bytes)> = vec![];
         let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
         macro_rules! sweep_each_query {
@@ -299,45 +304,74 @@ impl RootDatabase {
             )*}
         }
         sweep_each_query![
+            // SourceDatabase
             ra_db::ParseQuery
             ra_db::SourceRootCratesQuery
+
+            // AstDatabase
             hir::db::AstIdMapQuery
-            hir::db::ParseMacroQuery
-            hir::db::MacroDefQuery
+            hir::db::InternMacroQuery
             hir::db::MacroArgQuery
+            hir::db::MacroDefQuery
+            hir::db::ParseMacroQuery
             hir::db::MacroExpandQuery
+
+            // DefDatabase
+            hir::db::RawItemsQuery
+            hir::db::ComputeCrateDefMapQuery
             hir::db::StructDataQuery
+            hir::db::UnionDataQuery
             hir::db::EnumDataQuery
+            hir::db::ImplDataQuery
             hir::db::TraitDataQuery
-            hir::db::RawItemsQuery
-            hir::db::ComputeCrateDefMapQuery
-            hir::db::GenericParamsQuery
-            hir::db::FunctionDataQuery
             hir::db::TypeAliasDataQuery
+            hir::db::FunctionDataQuery
             hir::db::ConstDataQuery
             hir::db::StaticDataQuery
+            hir::db::BodyWithSourceMapQuery
+            hir::db::BodyQuery
+            hir::db::ExprScopesQuery
+            hir::db::GenericParamsQuery
+            hir::db::AttrsQuery
             hir::db::ModuleLangItemsQuery
             hir::db::CrateLangItemsQuery
             hir::db::LangItemQuery
             hir::db::DocumentationQuery
-            hir::db::ExprScopesQuery
+
+            // InternDatabase
+            hir::db::InternFunctionQuery
+            hir::db::InternStructQuery
+            hir::db::InternUnionQuery
+            hir::db::InternEnumQuery
+            hir::db::InternConstQuery
+            hir::db::InternStaticQuery
+            hir::db::InternTraitQuery
+            hir::db::InternTypeAliasQuery
+            hir::db::InternImplQuery
+
+            // HirDatabase
             hir::db::DoInferQuery
             hir::db::TyQuery
             hir::db::ValueTyQuery
+            hir::db::ImplSelfTyQuery
+            hir::db::ImplTraitQuery
             hir::db::FieldTypesQuery
             hir::db::CallableItemSignatureQuery
+            hir::db::GenericPredicatesForParamQuery
             hir::db::GenericPredicatesQuery
             hir::db::GenericDefaultsQuery
-            hir::db::BodyWithSourceMapQuery
-            hir::db::BodyQuery
             hir::db::ImplsInCrateQuery
             hir::db::ImplsForTraitQuery
+            hir::db::TraitSolverQuery
+            hir::db::InternTypeCtorQuery
+            hir::db::InternChalkImplQuery
+            hir::db::InternAssocTyValueQuery
             hir::db::AssociatedTyDataQuery
+            hir::db::AssociatedTyValueQuery
+            hir::db::TraitSolveQuery
             hir::db::TraitDatumQuery
             hir::db::StructDatumQuery
             hir::db::ImplDatumQuery
-            hir::db::ImplDataQuery
-            hir::db::TraitSolveQuery
         ];
         acc.sort_by_key(|it| std::cmp::Reverse(it.1));
         acc
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
new file mode 100644
index 000000000..030f44f86
--- /dev/null
+++ b/crates/ra_ide_db/src/defs.rs
@@ -0,0 +1,172 @@
+//! `NameDefinition` keeps information about the element we want to search references for.
+//! The element is represented by `NameKind`. It's located inside some `container` and
+//! has a `visibility`, which defines a search scope.
+//! Note that the reference search is possible for not all of the classified items.
+
+// FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
+
+use hir::{
+    Adt, HasSource, ImplBlock, InFile, Local, MacroDef, Module, ModuleDef, SourceBinder,
+    StructField, TypeParam, VariantDef,
+};
+use ra_prof::profile;
+use ra_syntax::{
+    ast::{self, AstNode, VisibilityOwner},
+    match_ast,
+};
+
+use crate::RootDatabase;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum NameKind {
+    Macro(MacroDef),
+    StructField(StructField),
+    ModuleDef(ModuleDef),
+    SelfType(ImplBlock),
+    Local(Local),
+    TypeParam(TypeParam),
+}
+
+#[derive(PartialEq, Eq)]
+pub struct NameDefinition {
+    pub visibility: Option<ast::Visibility>,
+    /// FIXME: this doesn't really make sense. For example, builtin types don't
+    /// really have a module.
+    pub container: Module,
+    pub kind: NameKind,
+}
+
+pub fn classify_name(
+    sb: &mut SourceBinder<RootDatabase>,
+    name: InFile<&ast::Name>,
+) -> Option<NameDefinition> {
+    let _p = profile("classify_name");
+    let parent = name.value.syntax().parent()?;
+
+    match_ast! {
+        match parent {
+            ast::BindPat(it) => {
+                let src = name.with_value(it);
+                let local = sb.to_def(src)?;
+                Some(NameDefinition {
+                    visibility: None,
+                    container: local.module(sb.db),
+                    kind: NameKind::Local(local),
+                })
+            },
+            ast::RecordFieldDef(it) => {
+                let src = name.with_value(it);
+                let field: hir::StructField = sb.to_def(src)?;
+                Some(from_struct_field(sb.db, field))
+            },
+            ast::Module(it) => {
+                let def = sb.to_def(name.with_value(it))?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::StructDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Struct = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::EnumDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Enum = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::TraitDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Trait = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::StaticDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Static = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::EnumVariant(it) => {
+                let src = name.with_value(it);
+                let def: hir::EnumVariant = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::FnDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Function = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::ConstDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::Const = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::TypeAliasDef(it) => {
+                let src = name.with_value(it);
+                let def: hir::TypeAlias = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
+            },
+            ast::MacroCall(it) => {
+                let src = name.with_value(it);
+                let def = sb.to_def(src.clone())?;
+
+                let module = sb.to_module_def(src.file_id.original_file(sb.db))?;
+
+                Some(NameDefinition {
+                    visibility: None,
+                    container: module,
+                    kind: NameKind::Macro(def),
+                })
+            },
+            ast::TypeParam(it) => {
+                let src = name.with_value(it);
+                let def = sb.to_def(src)?;
+                Some(NameDefinition {
+                    visibility: None,
+                    container: def.module(sb.db),
+                    kind: NameKind::TypeParam(def),
+                })
+            },
+            _ => None,
+        }
+    }
+}
+
+pub fn from_struct_field(db: &RootDatabase, field: StructField) -> NameDefinition {
+    let kind = NameKind::StructField(field);
+    let parent = field.parent_def(db);
+    let container = parent.module(db);
+    let visibility = match parent {
+        VariantDef::Struct(s) => s.source(db).value.visibility(),
+        VariantDef::Union(e) => e.source(db).value.visibility(),
+        VariantDef::EnumVariant(e) => e.source(db).value.parent_enum().visibility(),
+    };
+    NameDefinition { kind, container, visibility }
+}
+
+pub fn from_module_def(
+    db: &RootDatabase,
+    def: ModuleDef,
+    module: Option<Module>,
+) -> NameDefinition {
+    let kind = NameKind::ModuleDef(def);
+    let (container, visibility) = match def {
+        ModuleDef::Module(it) => {
+            let container = it.parent(db).or_else(|| Some(it)).unwrap();
+            let visibility = it.declaration_source(db).and_then(|s| s.value.visibility());
+            (container, visibility)
+        }
+        ModuleDef::EnumVariant(it) => {
+            let container = it.module(db);
+            let visibility = it.source(db).value.parent_enum().visibility();
+            (container, visibility)
+        }
+        ModuleDef::Function(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Const(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Static(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Trait(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).value.visibility()),
+        ModuleDef::BuiltinType(..) => (module.unwrap(), None),
+    };
+    NameDefinition { kind, container, visibility }
+}
diff --git a/crates/ra_ide/src/feature_flags.rs b/crates/ra_ide_db/src/feature_flags.rs
index 85617640d..1b3cabf4d 100644
--- a/crates/ra_ide/src/feature_flags.rs
+++ b/crates/ra_ide_db/src/feature_flags.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! See docs for `FeatureFlags`.
 
 use rustc_hash::FxHashMap;
 
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
new file mode 100644
index 000000000..86383bcd0
--- /dev/null
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -0,0 +1,72 @@
+//! This module contains an import search funcionality that is provided to the ra_assists module.
+//! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
+
+use hir::{db::HirDatabase, ModuleDef, SourceBinder};
+use ra_prof::profile;
+use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
+
+use crate::{
+    defs::classify_name,
+    defs::NameKind,
+    symbol_index::{self, FileSymbol, Query},
+    RootDatabase,
+};
+
+pub struct ImportsLocator<'a> {
+    source_binder: SourceBinder<'a, RootDatabase>,
+}
+
+impl<'a> ImportsLocator<'a> {
+    pub fn new(db: &'a RootDatabase) -> Self {
+        Self { source_binder: SourceBinder::new(db) }
+    }
+
+    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
+        let _p = profile("search_for_imports");
+        let db = self.source_binder.db;
+
+        let project_results = {
+            let mut query = Query::new(name_to_import.to_string());
+            query.exact();
+            query.limit(40);
+            symbol_index::world_symbols(db, query)
+        };
+        let lib_results = {
+            let mut query = Query::new(name_to_import.to_string());
+            query.libs();
+            query.exact();
+            query.limit(40);
+            symbol_index::world_symbols(db, query)
+        };
+
+        project_results
+            .into_iter()
+            .chain(lib_results.into_iter())
+            .filter_map(|import_candidate| self.get_name_definition(db, &import_candidate))
+            .filter_map(|name_definition_to_import| match name_definition_to_import {
+                NameKind::ModuleDef(module_def) => Some(module_def),
+                _ => None,
+            })
+            .collect()
+    }
+
+    fn get_name_definition(
+        &mut self,
+        db: &impl HirDatabase,
+        import_candidate: &FileSymbol,
+    ) -> Option<NameKind> {
+        let _p = profile("get_name_definition");
+        let file_id = import_candidate.file_id.into();
+        let candidate_node = import_candidate.ptr.to_node(&db.parse_or_expand(file_id)?);
+        let candidate_name_node = if candidate_node.kind() != NAME {
+            candidate_node.children().find(|it| it.kind() == NAME)?
+        } else {
+            candidate_node
+        };
+        classify_name(
+            &mut self.source_binder,
+            hir::InFile { file_id, value: &ast::Name::cast(candidate_name_node)? },
+        )
+        .map(|it| it.kind)
+    }
+}
diff --git a/crates/ra_ide/src/db.rs b/crates/ra_ide_db/src/lib.rs
index 47d0aed6f..877ac3c38 100644
--- a/crates/ra_ide/src/db.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -1,4 +1,15 @@
-//! FIXME: write short doc here
+//! This crate defines the core datastructure representing IDE state -- `RootDatabase`.
+//!
+//! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
+
+pub mod line_index;
+pub mod line_index_utils;
+pub mod feature_flags;
+pub mod symbol_index;
+pub mod change;
+pub mod defs;
+pub mod imports_locator;
+mod wasm_shims;
 
 use std::sync::Arc;
 
@@ -9,10 +20,7 @@ use ra_db::{
 };
 use rustc_hash::FxHashMap;
 
-use crate::{
-    symbol_index::{self, SymbolsDatabase},
-    FeatureFlags, LineIndex,
-};
+use crate::{feature_flags::FeatureFlags, line_index::LineIndex, symbol_index::SymbolsDatabase};
 
 #[salsa::database(
     ra_db::SourceDatabaseStorage,
@@ -25,12 +33,12 @@ use crate::{
     hir::db::HirDatabaseStorage
 )]
 #[derive(Debug)]
-pub(crate) struct RootDatabase {
+pub struct RootDatabase {
     runtime: salsa::Runtime<RootDatabase>,
-    pub(crate) feature_flags: Arc<FeatureFlags>,
+    pub feature_flags: Arc<FeatureFlags>,
     pub(crate) debug_data: Arc<DebugData>,
-    pub(crate) last_gc: crate::wasm_shims::Instant,
-    pub(crate) last_gc_check: crate::wasm_shims::Instant,
+    pub last_gc: crate::wasm_shims::Instant,
+    pub last_gc_check: crate::wasm_shims::Instant,
 }
 
 impl FileLoader for RootDatabase {
@@ -109,7 +117,7 @@ impl salsa::ParallelDatabase for RootDatabase {
 }
 
 #[salsa::query_group(LineIndexDatabaseStorage)]
-pub(crate) trait LineIndexDatabase: ra_db::SourceDatabase + CheckCanceled {
+pub trait LineIndexDatabase: ra_db::SourceDatabase + CheckCanceled {
     fn line_index(&self, file_id: FileId) -> Arc<LineIndex>;
 }
 
diff --git a/crates/ra_ide/src/line_index.rs b/crates/ra_ide_db/src/line_index.rs
index 710890d27..452c87ac5 100644
--- a/crates/ra_ide/src/line_index.rs
+++ b/crates/ra_ide_db/src/line_index.rs
@@ -1,6 +1,7 @@
-//! FIXME: write short doc here
+//! `LineIndex` maps flat `TextUnit` offsets into `(Line, Column)`
+//! representation.
 
-use crate::TextUnit;
+use ra_syntax::TextUnit;
 use rustc_hash::FxHashMap;
 use superslice::Ext;
 
diff --git a/crates/ra_ide/src/line_index_utils.rs b/crates/ra_ide_db/src/line_index_utils.rs
index bd1e08feb..435b06511 100644
--- a/crates/ra_ide/src/line_index_utils.rs
+++ b/crates/ra_ide_db/src/line_index_utils.rs
@@ -1,9 +1,87 @@
-//! FIXME: write short doc here
+//! Code actions can specify desirable final position of the cursor.
+//!
+//! The position is specified as a `TextUnit` in the final file. We need to send
+//! it in `(Line, Column)` coordinate though. However, we only have a LineIndex
+//! for a file pre-edit!
+//!
+//! Code in this module applies this "to (Line, Column) after edit"
+//! transformation.
 
-use crate::{line_index::Utf16Char, LineCol, LineIndex};
 use ra_syntax::{TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 
+use crate::line_index::{LineCol, LineIndex, Utf16Char};
+
+pub fn translate_offset_with_edit(
+    line_index: &LineIndex,
+    offset: TextUnit,
+    text_edit: &TextEdit,
+) -> LineCol {
+    let mut state = Edits::from_text_edit(&text_edit);
+
+    let mut res = RunningLineCol::new();
+
+    macro_rules! test_step {
+        ($x:ident) => {
+            match &$x {
+                Step::Newline(n) => {
+                    if offset < *n {
+                        return res.to_line_col(offset);
+                    } else {
+                        res.add_line(*n);
+                    }
+                }
+                Step::Utf16Char(x) => {
+                    if offset < x.end() {
+                        // if the offset is inside a multibyte char it's invalid
+                        // clamp it to the start of the char
+                        let clamp = offset.min(x.start());
+                        return res.to_line_col(clamp);
+                    } else {
+                        res.adjust_col(*x);
+                    }
+                }
+            }
+        };
+    }
+
+    for orig_step in LineIndexStepIter::from(line_index) {
+        loop {
+            let translated_step = state.translate_step(&orig_step);
+            match state.next_steps(&translated_step) {
+                NextSteps::Use => {
+                    test_step!(translated_step);
+                    break;
+                }
+                NextSteps::ReplaceMany(ns) => {
+                    for n in ns {
+                        test_step!(n);
+                    }
+                    break;
+                }
+                NextSteps::AddMany(ns) => {
+                    for n in ns {
+                        test_step!(n);
+                    }
+                }
+            }
+        }
+    }
+
+    loop {
+        match state.next_inserted_steps() {
+            None => break,
+            Some(ns) => {
+                for n in ns {
+                    test_step!(n);
+                }
+            }
+        }
+    }
+
+    res.to_line_col(offset)
+}
+
 #[derive(Debug, Clone)]
 enum Step {
     Newline(TextUnit),
@@ -17,7 +95,7 @@ struct LineIndexStepIter<'a> {
     utf16_chars: Option<(TextUnit, std::slice::Iter<'a, Utf16Char>)>,
 }
 
-impl<'a> LineIndexStepIter<'a> {
+impl LineIndexStepIter<'_> {
     fn from(line_index: &LineIndex) -> LineIndexStepIter {
         let mut x = LineIndexStepIter { line_index, next_newline_idx: 0, utf16_chars: None };
         // skip first newline since it's not real
@@ -26,7 +104,7 @@ impl<'a> LineIndexStepIter<'a> {
     }
 }
 
-impl<'a> Iterator for LineIndexStepIter<'a> {
+impl Iterator for LineIndexStepIter<'_> {
     type Item = Step;
     fn next(&mut self) -> Option<Step> {
         self.utf16_chars
@@ -54,7 +132,7 @@ struct OffsetStepIter<'a> {
     offset: TextUnit,
 }
 
-impl<'a> Iterator for OffsetStepIter<'a> {
+impl Iterator for OffsetStepIter<'_> {
     type Item = Step;
     fn next(&mut self) -> Option<Step> {
         let (next, next_offset) = self
@@ -220,84 +298,16 @@ impl RunningLineCol {
     }
 }
 
-pub fn translate_offset_with_edit(
-    line_index: &LineIndex,
-    offset: TextUnit,
-    text_edit: &TextEdit,
-) -> LineCol {
-    let mut state = Edits::from_text_edit(&text_edit);
-
-    let mut res = RunningLineCol::new();
-
-    macro_rules! test_step {
-        ($x:ident) => {
-            match &$x {
-                Step::Newline(n) => {
-                    if offset < *n {
-                        return res.to_line_col(offset);
-                    } else {
-                        res.add_line(*n);
-                    }
-                }
-                Step::Utf16Char(x) => {
-                    if offset < x.end() {
-                        // if the offset is inside a multibyte char it's invalid
-                        // clamp it to the start of the char
-                        let clamp = offset.min(x.start());
-                        return res.to_line_col(clamp);
-                    } else {
-                        res.adjust_col(*x);
-                    }
-                }
-            }
-        };
-    }
-
-    for orig_step in LineIndexStepIter::from(line_index) {
-        loop {
-            let translated_step = state.translate_step(&orig_step);
-            match state.next_steps(&translated_step) {
-                NextSteps::Use => {
-                    test_step!(translated_step);
-                    break;
-                }
-                NextSteps::ReplaceMany(ns) => {
-                    for n in ns {
-                        test_step!(n);
-                    }
-                    break;
-                }
-                NextSteps::AddMany(ns) => {
-                    for n in ns {
-                        test_step!(n);
-                    }
-                }
-            }
-        }
-    }
-
-    loop {
-        match state.next_inserted_steps() {
-            None => break,
-            Some(ns) => {
-                for n in ns {
-                    test_step!(n);
-                }
-            }
-        }
-    }
-
-    res.to_line_col(offset)
-}
-
 #[cfg(test)]
 mod test {
-    use super::*;
-    use crate::line_index;
     use proptest::{prelude::*, proptest};
     use ra_text_edit::test_utils::{arb_offset, arb_text_with_edit};
     use ra_text_edit::TextEdit;
 
+    use crate::line_index;
+
+    use super::*;
+
     #[derive(Debug)]
     struct ArbTextWithEditAndOffset {
         text: String,
diff --git a/crates/ra_ide/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index 5729eb5b3..64ddf2f95 100644
--- a/crates/ra_ide/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -19,6 +19,7 @@
 //! for each library (which is assumed to never change) and an FST for each Rust
 //! file in the current workspace, and run a query against the union of all
 //! those FSTs.
+
 use std::{
     fmt,
     hash::{Hash, Hasher},
@@ -29,7 +30,7 @@ use std::{
 use fst::{self, Streamer};
 use ra_db::{
     salsa::{self, ParallelDatabase},
-    SourceDatabaseExt, SourceRootId,
+    FileId, SourceDatabaseExt, SourceRootId,
 };
 use ra_syntax::{
     ast::{self, NameOwner},
@@ -40,10 +41,50 @@ use ra_syntax::{
 #[cfg(not(feature = "wasm"))]
 use rayon::prelude::*;
 
-use crate::{db::RootDatabase, FileId, Query};
+use crate::RootDatabase;
+
+#[derive(Debug)]
+pub struct Query {
+    query: String,
+    lowercased: String,
+    only_types: bool,
+    libs: bool,
+    exact: bool,
+    limit: usize,
+}
+
+impl Query {
+    pub fn new(query: String) -> Query {
+        let lowercased = query.to_lowercase();
+        Query {
+            query,
+            lowercased,
+            only_types: false,
+            libs: false,
+            exact: false,
+            limit: usize::max_value(),
+        }
+    }
+
+    pub fn only_types(&mut self) {
+        self.only_types = true;
+    }
+
+    pub fn libs(&mut self) {
+        self.libs = true;
+    }
+
+    pub fn exact(&mut self) {
+        self.exact = true;
+    }
+
+    pub fn limit(&mut self, limit: usize) {
+        self.limit = limit
+    }
+}
 
 #[salsa::query_group(SymbolsDatabaseStorage)]
-pub(crate) trait SymbolsDatabase: hir::db::HirDatabase {
+pub trait SymbolsDatabase: hir::db::HirDatabase {
     fn file_symbols(&self, file_id: FileId) -> Arc<SymbolIndex>;
     #[salsa::input]
     fn library_symbols(&self, id: SourceRootId) -> Arc<SymbolIndex>;
@@ -68,7 +109,7 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
     Arc::new(SymbolIndex::new(symbols))
 }
 
-pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
+pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
     /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
     struct Snap(salsa::Snapshot<RootDatabase>);
     impl Clone for Snap {
@@ -110,16 +151,16 @@ pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol>
     query.search(&buf)
 }
 
-pub(crate) fn index_resolve(db: &RootDatabase, name_ref: &ast::NameRef) -> Vec<FileSymbol> {
+pub fn index_resolve(db: &RootDatabase, name_ref: &ast::NameRef) -> Vec<FileSymbol> {
     let name = name_ref.text();
     let mut query = Query::new(name.to_string());
     query.exact();
     query.limit(4);
-    crate::symbol_index::world_symbols(db, query)
+    world_symbols(db, query)
 }
 
 #[derive(Default)]
-pub(crate) struct SymbolIndex {
+pub struct SymbolIndex {
     symbols: Vec<FileSymbol>,
     map: fst::Map,
 }
@@ -178,11 +219,11 @@ impl SymbolIndex {
         SymbolIndex { symbols, map }
     }
 
-    pub(crate) fn len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.symbols.len()
     }
 
-    pub(crate) fn memory_size(&self) -> usize {
+    pub fn memory_size(&self) -> usize {
         self.map.as_fst().size() + self.symbols.len() * mem::size_of::<FileSymbol>()
     }
 
@@ -262,12 +303,12 @@ fn is_type(kind: SyntaxKind) -> bool {
 /// The actual data that is stored in the index. It should be as compact as
 /// possible.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct FileSymbol {
-    pub(crate) file_id: FileId,
-    pub(crate) name: SmolStr,
-    pub(crate) ptr: SyntaxNodePtr,
-    pub(crate) name_range: Option<TextRange>,
-    pub(crate) container_name: Option<SmolStr>,
+pub struct FileSymbol {
+    pub file_id: FileId,
+    pub name: SmolStr,
+    pub ptr: SyntaxNodePtr,
+    pub name_range: Option<TextRange>,
+    pub container_name: Option<SmolStr>,
 }
 
 fn source_file_to_file_symbols(source_file: &SourceFile, file_id: FileId) -> Vec<FileSymbol> {
@@ -329,77 +370,3 @@ fn to_file_symbol(node: &SyntaxNode, file_id: FileId) -> Option<FileSymbol> {
         container_name: None,
     })
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{display::NavigationTarget, mock_analysis::single_file, Query};
-    use ra_syntax::{
-        SmolStr,
-        SyntaxKind::{FN_DEF, STRUCT_DEF},
-    };
-
-    #[test]
-    fn test_world_symbols_with_no_container() {
-        let code = r#"
-    enum FooInner { }
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name(), "FooInner");
-        assert!(s.container_name().is_none());
-    }
-
-    #[test]
-    fn test_world_symbols_include_container_name() {
-        let code = r#"
-fn foo() {
-    enum FooInner { }
-}
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name(), "FooInner");
-        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
-
-        let code = r#"
-mod foo {
-    struct FooInner;
-}
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name(), "FooInner");
-        assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
-    }
-
-    #[test]
-    fn test_world_symbols_are_case_sensitive() {
-        let code = r#"
-fn foo() {}
-
-struct Foo;
-        "#;
-
-        let symbols = get_symbols_matching(code, "Foo");
-
-        let fn_match = symbols.iter().find(|s| s.name() == "foo").map(|s| s.kind());
-        let struct_match = symbols.iter().find(|s| s.name() == "Foo").map(|s| s.kind());
-
-        assert_eq!(fn_match, Some(FN_DEF));
-        assert_eq!(struct_match, Some(STRUCT_DEF));
-    }
-
-    fn get_symbols_matching(text: &str, query: &str) -> Vec<NavigationTarget> {
-        let (analysis, _) = single_file(text);
-        analysis.symbol_search(Query::new(query.into())).unwrap()
-    }
-}
diff --git a/crates/ra_ide/src/wasm_shims.rs b/crates/ra_ide_db/src/wasm_shims.rs
index 088cc9be4..7af9f9d9b 100644
--- a/crates/ra_ide/src/wasm_shims.rs
+++ b/crates/ra_ide_db/src/wasm_shims.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! A version of `std::time::Instant` that doesn't panic in WASM.
 
 #[cfg(not(feature = "wasm"))]
 pub use std::time::Instant;
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 4ee3fb49f..fdf81ed87 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -26,10 +26,13 @@ lsp-server = "0.3.0"
 ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
 ra_vfs_glob = { path = "../ra_vfs_glob" }
-env_logger = { version = "0.7.1", default-features = false, features = ["humantime"] }
+env_logger = { version = "0.7.1", default-features = false }
 ra_cargo_watch = { path = "../ra_cargo_watch" }
 either = "1.5"
 
+[target.'cfg(windows)'.dependencies]
+winapi = "0.3"
+
 [dev-dependencies]
 tempfile = "3"
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_lsp_server/src/diagnostics.rs b/crates/ra_lsp_server/src/diagnostics.rs
new file mode 100644
index 000000000..ea08bce24
--- /dev/null
+++ b/crates/ra_lsp_server/src/diagnostics.rs
@@ -0,0 +1,85 @@
+//! Book keeping for keeping diagnostics easily in sync with the client.
+use lsp_types::{CodeActionOrCommand, Diagnostic, Range};
+use ra_ide::FileId;
+use std::{collections::HashMap, sync::Arc};
+
+pub type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
+
+#[derive(Debug, Default, Clone)]
+pub struct DiagnosticCollection {
+    pub native: HashMap<FileId, Vec<Diagnostic>>,
+    pub check: HashMap<FileId, Vec<Diagnostic>>,
+    pub check_fixes: CheckFixes,
+}
+
+#[derive(Debug, Clone)]
+pub struct Fix {
+    pub range: Range,
+    pub action: CodeActionOrCommand,
+}
+
+#[derive(Debug)]
+pub enum DiagnosticTask {
+    ClearCheck,
+    AddCheck(FileId, Diagnostic, Vec<CodeActionOrCommand>),
+    SetNative(FileId, Vec<Diagnostic>),
+}
+
+impl DiagnosticCollection {
+    pub fn clear_check(&mut self) -> Vec<FileId> {
+        Arc::make_mut(&mut self.check_fixes).clear();
+        self.check.drain().map(|(key, _value)| key).collect()
+    }
+
+    pub fn add_check_diagnostic(
+        &mut self,
+        file_id: FileId,
+        diagnostic: Diagnostic,
+        fixes: Vec<CodeActionOrCommand>,
+    ) {
+        let diagnostics = self.check.entry(file_id).or_default();
+        for existing_diagnostic in diagnostics.iter() {
+            if are_diagnostics_equal(&existing_diagnostic, &diagnostic) {
+                return;
+            }
+        }
+
+        let check_fixes = Arc::make_mut(&mut self.check_fixes);
+        check_fixes
+            .entry(file_id)
+            .or_default()
+            .extend(fixes.into_iter().map(|action| Fix { range: diagnostic.range, action }));
+        diagnostics.push(diagnostic);
+    }
+
+    pub fn set_native_diagnostics(&mut self, file_id: FileId, diagnostics: Vec<Diagnostic>) {
+        self.native.insert(file_id, diagnostics);
+    }
+
+    pub fn diagnostics_for(&self, file_id: FileId) -> impl Iterator<Item = &Diagnostic> {
+        let native = self.native.get(&file_id).into_iter().flatten();
+        let check = self.check.get(&file_id).into_iter().flatten();
+        native.chain(check)
+    }
+
+    pub fn handle_task(&mut self, task: DiagnosticTask) -> Vec<FileId> {
+        match task {
+            DiagnosticTask::ClearCheck => self.clear_check(),
+            DiagnosticTask::AddCheck(file_id, diagnostic, fixes) => {
+                self.add_check_diagnostic(file_id, diagnostic, fixes);
+                vec![file_id]
+            }
+            DiagnosticTask::SetNative(file_id, diagnostics) => {
+                self.set_native_diagnostics(file_id, diagnostics);
+                vec![file_id]
+            }
+        }
+    }
+}
+
+fn are_diagnostics_equal(left: &Diagnostic, right: &Diagnostic) -> bool {
+    left.source == right.source
+        && left.severity == right.severity
+        && left.range == right.range
+        && left.message == right.message
+}
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 2ca149fd5..1208c1343 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -29,6 +29,7 @@ mod markdown;
 pub mod req;
 mod config;
 mod world;
+mod diagnostics;
 
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 pub use crate::{
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 7822be2e2..ceff82fda 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -5,21 +5,29 @@ mod handlers;
 mod subscriptions;
 pub(crate) mod pending_requests;
 
-use std::{error::Error, fmt, panic, path::PathBuf, sync::Arc, time::Instant};
+use std::{
+    env,
+    error::Error,
+    fmt, panic,
+    path::PathBuf,
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
-use lsp_types::{ClientCapabilities, NumberOrString, Url};
-use ra_cargo_watch::{CheckOptions, CheckTask};
+use lsp_types::{ClientCapabilities, NumberOrString};
+use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckTask};
 use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
-use ra_vfs::{VfsTask, Watch};
+use ra_vfs::{VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
 
 use crate::{
+    diagnostics::DiagnosticTask,
     main_loop::{
         pending_requests::{PendingRequest, PendingRequests},
         subscriptions::Subscriptions,
@@ -29,9 +37,6 @@ use crate::{
     Result, ServerConfig,
 };
 
-const THREADPOOL_SIZE: usize = 8;
-const MAX_IN_FLIGHT_LIBS: usize = THREADPOOL_SIZE - 3;
-
 #[derive(Debug)]
 pub struct LspError {
     pub code: i32,
@@ -60,6 +65,25 @@ pub fn main_loop(
 ) -> Result<()> {
     log::info!("server_config: {:#?}", config);
 
+    // Windows scheduler implements priority boosts: if thread waits for an
+    // event (like a condvar), and event fires, priority of the thread is
+    // temporary bumped. This optimization backfires in our case: each time the
+    // `main_loop` schedules a task to run on a threadpool, the worker threads
+    // gets a higher priority, and (on a machine with fewer cores) displaces the
+    // main loop! We work-around this by marking the main loop as a
+    // higher-priority thread.
+    //
+    // https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities
+    // https://docs.microsoft.com/en-us/windows/win32/procthread/priority-boosts
+    // https://github.com/rust-analyzer/rust-analyzer/issues/2835
+    #[cfg(windows)]
+    unsafe {
+        use winapi::um::processthreadsapi::*;
+        let thread = GetCurrentThread();
+        let thread_priority_above_normal = 1;
+        SetThreadPriority(thread, thread_priority_above_normal);
+    }
+
     let mut loop_state = LoopState::default();
     let mut world_state = {
         let feature_flags = {
@@ -168,7 +192,7 @@ pub fn main_loop(
         )
     };
 
-    let pool = ThreadPool::new(THREADPOOL_SIZE);
+    let pool = ThreadPool::default();
     let (task_sender, task_receiver) = unbounded::<Task>();
     let (libdata_sender, libdata_receiver) = unbounded::<LibraryData>();
 
@@ -210,7 +234,7 @@ pub fn main_loop(
             )?;
         }
     }
-
+    world_state.analysis_host.request_cancellation();
     log::info!("waiting for tasks to finish...");
     task_receiver.into_iter().for_each(|task| {
         on_task(task, &connection.sender, &mut loop_state.pending_requests, &mut world_state)
@@ -231,6 +255,7 @@ pub fn main_loop(
 enum Task {
     Respond(Response),
     Notify(Notification),
+    Diagnostic(DiagnosticTask),
 }
 
 enum Event {
@@ -371,7 +396,8 @@ fn loop_turn(
         loop_state.pending_libraries.extend(changes);
     }
 
-    while loop_state.in_flight_libraries < MAX_IN_FLIGHT_LIBS
+    let max_in_flight_libs = pool.max_count().saturating_sub(2).max(1);
+    while loop_state.in_flight_libraries < max_in_flight_libs
         && !loop_state.pending_libraries.is_empty()
     {
         let (root, files) = loop_state.pending_libraries.pop().unwrap();
@@ -379,7 +405,6 @@ fn loop_turn(
         let sender = libdata_sender.clone();
         pool.execute(move || {
             log::info!("indexing {:?} ... ", root);
-            let _p = profile(&format!("indexed {:?}", root));
             let data = LibraryData::prepare(root, files);
             sender.send(data).unwrap();
         });
@@ -408,6 +433,19 @@ fn loop_turn(
             loop_state.subscriptions.subscriptions(),
         )
     }
+
+    let loop_duration = loop_start.elapsed();
+    if loop_duration > Duration::from_millis(100) {
+        log::error!("overly long loop turn: {:?}", loop_duration);
+        if env::var("RA_PROFILE").is_ok() {
+            show_message(
+                req::MessageType::Error,
+                format!("overly long loop turn: {:?}", loop_duration),
+                &connection.sender,
+            );
+        }
+    }
+
     Ok(())
 }
 
@@ -428,6 +466,7 @@ fn on_task(
         Task::Notify(n) => {
             msg_sender.send(n.into()).unwrap();
         }
+        Task::Diagnostic(task) => on_diagnostic_task(task, msg_sender, state),
     }
 }
 
@@ -435,7 +474,7 @@ fn on_request(
     world: &mut WorldState,
     pending_requests: &mut PendingRequests,
     pool: &ThreadPool,
-    sender: &Sender<Task>,
+    task_sender: &Sender<Task>,
     msg_sender: &Sender<Message>,
     request_received: Instant,
     req: Request,
@@ -444,7 +483,7 @@ fn on_request(
         req: Some(req),
         pool,
         world,
-        sender,
+        task_sender,
         msg_sender,
         pending_requests,
         request_received,
@@ -586,30 +625,26 @@ fn on_notification(
 
 fn on_check_task(
     task: CheckTask,
-    world_state: &WorldState,
+    world_state: &mut WorldState,
     task_sender: &Sender<Task>,
 ) -> Result<()> {
     match task {
         CheckTask::ClearDiagnostics => {
-            let cleared_files = world_state.check_watcher.state.write().clear();
-
-            // Send updated diagnostics for each cleared file
-            for url in cleared_files {
-                publish_diagnostics_for_url(&url, world_state, task_sender)?;
-            }
+            task_sender.send(Task::Diagnostic(DiagnosticTask::ClearCheck))?;
         }
 
-        CheckTask::AddDiagnostic(url, diagnostic) => {
-            world_state
-                .check_watcher
-                .state
-                .write()
-                .add_diagnostic_with_fixes(url.clone(), diagnostic);
-
-            // We manually send a diagnostic update when the watcher asks
-            // us to, to avoid the issue of having to change the file to
-            // receive updated diagnostics.
-            publish_diagnostics_for_url(&url, world_state, task_sender)?;
+        CheckTask::AddDiagnostic { url, diagnostic, fixes } => {
+            let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?;
+            let file_id = match world_state.vfs.read().path2file(&path) {
+                Some(file) => FileId(file.0),
+                None => {
+                    log::error!("File with cargo diagnostic not found in VFS: {}", path.display());
+                    return Ok(());
+                }
+            };
+
+            task_sender
+                .send(Task::Diagnostic(DiagnosticTask::AddCheck(file_id, diagnostic, fixes)))?;
         }
 
         CheckTask::Status(progress) => {
@@ -620,22 +655,29 @@ fn on_check_task(
             let not = notification_new::<req::Progress>(params);
             task_sender.send(Task::Notify(not)).unwrap();
         }
-    }
+    };
+
     Ok(())
 }
 
-fn publish_diagnostics_for_url(
-    url: &Url,
-    world_state: &WorldState,
-    task_sender: &Sender<Task>,
-) -> Result<()> {
-    let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?;
-    if let Some(file_id) = world_state.vfs.read().path2file(&path) {
-        let params = handlers::publish_diagnostics(&world_state.snapshot(), FileId(file_id.0))?;
+fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state: &mut WorldState) {
+    let subscriptions = state.diagnostics.handle_task(task);
+
+    for file_id in subscriptions {
+        let path = state.vfs.read().file2path(VfsFile(file_id.0));
+        let uri = match url_from_path_with_drive_lowercasing(&path) {
+            Ok(uri) => uri,
+            Err(err) => {
+                log::error!("Couldn't convert path to url ({}): {:?}", err, path.to_string_lossy());
+                continue;
+            }
+        };
+
+        let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect();
+        let params = req::PublishDiagnosticsParams { uri, diagnostics, version: None };
         let not = notification_new::<req::PublishDiagnostics>(params);
-        task_sender.send(Task::Notify(not)).unwrap();
+        msg_sender.send(not.into()).unwrap();
     }
-    Ok(())
 }
 
 struct PoolDispatcher<'a> {
@@ -644,7 +686,7 @@ struct PoolDispatcher<'a> {
     world: &'a mut WorldState,
     pending_requests: &'a mut PendingRequests,
     msg_sender: &'a Sender<Message>,
-    sender: &'a Sender<Task>,
+    task_sender: &'a Sender<Task>,
     request_received: Instant,
 }
 
@@ -691,7 +733,7 @@ impl<'a> PoolDispatcher<'a> {
 
         self.pool.execute({
             let world = self.world.snapshot();
-            let sender = self.sender.clone();
+            let sender = self.task_sender.clone();
             move || {
                 let result = f(world, params);
                 let task = result_to_task::<R>(id, result);
@@ -769,7 +811,7 @@ fn update_file_notifications_on_threadpool(
     pool: &ThreadPool,
     world: WorldSnapshot,
     publish_decorations: bool,
-    sender: Sender<Task>,
+    task_sender: Sender<Task>,
     subscriptions: Vec<FileId>,
 ) {
     log::trace!("updating notifications for {:?}", subscriptions);
@@ -783,9 +825,8 @@ fn update_file_notifications_on_threadpool(
                             log::error!("failed to compute diagnostics: {:?}", e);
                         }
                     }
-                    Ok(params) => {
-                        let not = notification_new::<req::PublishDiagnostics>(params);
-                        sender.send(Task::Notify(not)).unwrap();
+                    Ok(task) => {
+                        task_sender.send(Task::Diagnostic(task)).unwrap();
                     }
                 }
             }
@@ -798,7 +839,7 @@ fn update_file_notifications_on_threadpool(
                     }
                     Ok(params) => {
                         let not = notification_new::<req::PublishDecorations>(params);
-                        sender.send(Task::Notify(not)).unwrap();
+                        task_sender.send(Task::Notify(not)).unwrap();
                     }
                 }
             }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 8e43f0575..65e8bc856 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -1,17 +1,22 @@
 //! This module is responsible for implementing handlers for Lanuage Server Protocol.
 //! The majority of requests are fulfilled by calling into the `ra_ide` crate.
 
-use std::{fmt::Write as _, io::Write as _};
+use std::{
+    collections::hash_map::Entry,
+    fmt::Write as _,
+    io::Write as _,
+    process::{self, Stdio},
+};
 
-use either::Either;
 use lsp_server::ErrorCode;
 use lsp_types::{
     CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
     CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
-    CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
-    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams,
-    Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
-    Range, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit, WorkspaceEdit,
+    CodeAction, CodeActionOrCommand, CodeActionResponse, CodeLens, Command, CompletionItem,
+    Diagnostic, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
+    FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
+    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
+    TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
     AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
@@ -29,6 +34,7 @@ use crate::{
         to_call_hierarchy_item, to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith,
         TryConvWithToVec,
     },
+    diagnostics::DiagnosticTask,
     req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
     world::WorldSnapshot,
     LspError, Result,
@@ -582,21 +588,19 @@ pub fn handle_formatting(
     let file_line_index = world.analysis().file_line_index(file_id)?;
     let end_position = TextUnit::of_str(&file).conv_with(&file_line_index);
 
-    use std::process;
     let mut rustfmt = process::Command::new("rustfmt");
     if let Some(&crate_id) = crate_ids.first() {
         // Assume all crates are in the same edition
         let edition = world.analysis().crate_edition(crate_id)?;
         rustfmt.args(&["--edition", &edition.to_string()]);
     }
-    rustfmt.stdin(process::Stdio::piped()).stdout(process::Stdio::piped());
 
     if let Ok(path) = params.text_document.uri.to_file_path() {
         if let Some(parent) = path.parent() {
             rustfmt.current_dir(parent);
         }
     }
-    let mut rustfmt = rustfmt.spawn()?;
+    let mut rustfmt = rustfmt.stdin(Stdio::piped()).stdout(Stdio::piped()).spawn()?;
 
     rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
 
@@ -674,59 +678,61 @@ pub fn handle_code_action(
         res.push(action.into());
     }
 
-    for fix in world.check_watcher.read().fixes_for(&params.text_document.uri).into_iter().flatten()
-    {
-        let fix_range = fix.location.range.conv_with(&line_index);
+    for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
+        let fix_range = fix.range.conv_with(&line_index);
         if fix_range.intersection(&range).is_none() {
             continue;
         }
+        res.push(fix.action.clone());
+    }
 
-        let edit = {
-            let edits = vec![TextEdit::new(fix.location.range, fix.replacement.clone())];
-            let mut edit_map = std::collections::HashMap::new();
-            edit_map.insert(fix.location.uri.clone(), edits);
-            WorkspaceEdit::new(edit_map)
+    let mut groups = FxHashMap::default();
+    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
+        let arg = to_value(assist.source_change.try_conv_with(&world)?)?;
+
+        let (command, title, arg) = match assist.group_label {
+            None => ("rust-analyzer.applySourceChange", assist.label.clone(), arg),
+
+            // Group all assists with the same `group_label` into a single CodeAction.
+            Some(group_label) => {
+                match groups.entry(group_label.clone()) {
+                    Entry::Occupied(entry) => {
+                        let idx: usize = *entry.get();
+                        match &mut res[idx] {
+                            CodeActionOrCommand::CodeAction(CodeAction {
+                                command: Some(Command { arguments: Some(arguments), .. }),
+                                ..
+                            }) => match arguments.as_mut_slice() {
+                                [serde_json::Value::Array(arguments)] => arguments.push(arg),
+                                _ => panic!("invalid group"),
+                            },
+                            _ => panic!("invalid group"),
+                        }
+                        continue;
+                    }
+                    Entry::Vacant(entry) => {
+                        entry.insert(res.len());
+                    }
+                }
+                ("rust-analyzer.selectAndApplySourceChange", group_label, to_value(vec![arg])?)
+            }
         };
 
-        let action = CodeAction {
-            title: fix.title.clone(),
-            kind: Some("quickfix".to_string()),
-            diagnostics: Some(fix.diagnostics.clone()),
-            edit: Some(edit),
-            command: None,
-            is_preferred: None,
+        let command = Command {
+            title: assist.label.clone(),
+            command: command.to_string(),
+            arguments: Some(vec![arg]),
         };
-        res.push(action.into());
-    }
 
-    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
-        let title = assist.label.clone();
-
-        let command = match assist.change_data {
-            Either::Left(change) => Command {
-                title,
-                command: "rust-analyzer.applySourceChange".to_string(),
-                arguments: Some(vec![to_value(change.try_conv_with(&world)?)?]),
-            },
-            Either::Right(changes) => Command {
-                title,
-                command: "rust-analyzer.selectAndApplySourceChange".to_string(),
-                arguments: Some(vec![to_value(
-                    changes
-                        .into_iter()
-                        .map(|change| change.try_conv_with(&world))
-                        .collect::<Result<Vec<_>>>()?,
-                )?]),
-            },
+        let kind = match assist.id {
+            AssistId("introduce_variable") => Some("refactor.extract.variable".to_string()),
+            AssistId("add_custom_impl") => Some("refactor.rewrite.add_custom_impl".to_string()),
+            _ => None,
         };
 
         let action = CodeAction {
-            title: command.title.clone(),
-            kind: match assist.id {
-                AssistId("introduce_variable") => Some("refactor.extract.variable".to_string()),
-                AssistId("add_custom_impl") => Some("refactor.rewrite.add_custom_impl".to_string()),
-                _ => None,
-            },
+            title,
+            kind,
             diagnostics: None,
             edit: None,
             command: Some(command),
@@ -874,14 +880,10 @@ pub fn handle_document_highlight(
     ))
 }
 
-pub fn publish_diagnostics(
-    world: &WorldSnapshot,
-    file_id: FileId,
-) -> Result<req::PublishDiagnosticsParams> {
+pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
     let _p = profile("publish_diagnostics");
-    let uri = world.file_id_to_uri(file_id)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let mut diagnostics: Vec<Diagnostic> = world
+    let diagnostics: Vec<Diagnostic> = world
         .analysis()
         .diagnostics(file_id)?
         .into_iter()
@@ -895,10 +897,7 @@ pub fn publish_diagnostics(
             tags: None,
         })
         .collect();
-    if let Some(check_diags) = world.check_watcher.read().diagnostics_for(&uri) {
-        diagnostics.extend(check_diags.iter().cloned());
-    }
-    Ok(req::PublishDiagnosticsParams { uri, diagnostics, version: None })
+    Ok(DiagnosticTask::SetNative(file_id, diagnostics))
 }
 
 pub fn publish_decorations(
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index e7a0acfc7..1ee02b47c 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -12,9 +12,7 @@ use crossbeam_channel::{unbounded, Receiver};
 use lsp_server::ErrorCode;
 use lsp_types::Url;
 use parking_lot::RwLock;
-use ra_cargo_watch::{
-    url_from_path_with_drive_lowercasing, CheckOptions, CheckState, CheckWatcher,
-};
+use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher};
 use ra_ide::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, FeatureFlags, FileId, LibraryData,
     SourceRootId,
@@ -25,6 +23,7 @@ use ra_vfs_glob::{Glob, RustPackageFilterBuilder};
 use relative_path::RelativePathBuf;
 
 use crate::{
+    diagnostics::{CheckFixes, DiagnosticCollection},
     main_loop::pending_requests::{CompletedRequest, LatestRequests},
     LspError, Result,
 };
@@ -55,6 +54,7 @@ pub struct WorldState {
     pub task_receiver: Receiver<VfsTask>,
     pub latest_requests: Arc<RwLock<LatestRequests>>,
     pub check_watcher: CheckWatcher,
+    pub diagnostics: DiagnosticCollection,
 }
 
 /// An immutable snapshot of the world's state at a point in time.
@@ -63,7 +63,7 @@ pub struct WorldSnapshot {
     pub workspaces: Arc<Vec<ProjectWorkspace>>,
     pub analysis: Analysis,
     pub latest_requests: Arc<RwLock<LatestRequests>>,
-    pub check_watcher: Arc<RwLock<CheckState>>,
+    pub check_fixes: CheckFixes,
     vfs: Arc<RwLock<Vfs>>,
 }
 
@@ -159,6 +159,7 @@ impl WorldState {
             task_receiver,
             latest_requests: Default::default(),
             check_watcher,
+            diagnostics: Default::default(),
         }
     }
 
@@ -220,7 +221,7 @@ impl WorldState {
             analysis: self.analysis_host.analysis(),
             vfs: Arc::clone(&self.vfs),
             latest_requests: Arc::clone(&self.latest_requests),
-            check_watcher: self.check_watcher.state.clone(),
+            check_fixes: Arc::clone(&self.diagnostics.check_fixes),
         }
     }
 
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index b841c39d3..c9f42b3dd 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use ra_parser::{Token, TokenSource};
-use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*, T};
+use ra_syntax::{lex_single_valid_syntax_kind, SmolStr, SyntaxKind, SyntaxKind::*, T};
 use std::cell::{Cell, Ref, RefCell};
 use tt::buffer::{Cursor, TokenBuffer};
 
@@ -129,8 +129,9 @@ fn convert_delim(d: Option<tt::DelimiterKind>, closing: bool) -> TtToken {
 }
 
 fn convert_literal(l: &tt::Literal) -> TtToken {
-    let kind =
-        classify_literal(&l.text).map(|tkn| tkn.kind).unwrap_or_else(|| match l.text.as_ref() {
+    let kind = lex_single_valid_syntax_kind(&l.text)
+        .filter(|kind| kind.is_literal())
+        .unwrap_or_else(|| match l.text.as_ref() {
             "true" => T![true],
             "false" => T![false],
             _ => panic!("Fail to convert given literal {:#?}", &l),
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 2cc321473..f154077a8 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -229,7 +229,7 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
     let m = p.start();
     p.eat(T![async]);
     p.eat(T![move]);
-    params::param_list_opt_types(p);
+    params::param_list_closure(p);
     if opt_fn_ret_type(p) {
         if !p.at(T!['{']) {
             p.error("expected `{`");
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index 6e23d9b72..54284c933 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -91,13 +91,6 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
     // modifiers
     has_mods |= p.eat(T![const]);
 
-    // test_err unsafe_block_in_mod
-    // fn foo(){} unsafe { } fn bar(){}
-    if p.at(T![unsafe]) && p.nth(1) != T!['{'] {
-        p.eat(T![unsafe]);
-        has_mods = true;
-    }
-
     // test_err async_without_semicolon
     // fn foo() { let _ = async {} }
     if p.at(T![async]) && p.nth(1) != T!['{'] && p.nth(1) != T![move] && p.nth(1) != T![|] {
@@ -105,6 +98,13 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
         has_mods = true;
     }
 
+    // test_err unsafe_block_in_mod
+    // fn foo(){} unsafe { } fn bar(){}
+    if p.at(T![unsafe]) && p.nth(1) != T!['{'] {
+        p.eat(T![unsafe]);
+        has_mods = true;
+    }
+
     if p.at(T![extern]) {
         has_mods = true;
         abi(p);
@@ -157,14 +157,14 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
         // unsafe fn foo() {}
 
         // test combined_fns
-        // unsafe async fn foo() {}
+        // async unsafe fn foo() {}
         // const unsafe fn bar() {}
 
         // test_err wrong_order_fns
-        // async unsafe fn foo() {}
+        // unsafe async fn foo() {}
         // unsafe const fn bar() {}
         T![fn] => {
-            fn_def(p, flavor);
+            fn_def(p);
             m.complete(p, FN_DEF);
         }
 
@@ -301,7 +301,7 @@ pub(crate) fn extern_item_list(p: &mut Parser) {
     m.complete(p, EXTERN_ITEM_LIST);
 }
 
-fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
+fn fn_def(p: &mut Parser) {
     assert!(p.at(T![fn]));
     p.bump(T![fn]);
 
@@ -311,10 +311,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
     type_params::opt_type_param_list(p);
 
     if p.at(T!['(']) {
-        match flavor {
-            ItemFlavor::Mod => params::param_list(p),
-            ItemFlavor::Trait => params::param_list_opt_patterns(p),
-        }
+        params::param_list_fn_def(p);
     } else {
         p.error("expected function arguments");
     }
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index c10b53316..94edc7f35 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -7,54 +7,60 @@ use super::*;
 // fn b(x: i32) {}
 // fn c(x: i32, ) {}
 // fn d(x: i32, y: ()) {}
-pub(super) fn param_list(p: &mut Parser) {
-    list_(p, Flavor::Normal)
+pub(super) fn param_list_fn_def(p: &mut Parser) {
+    list_(p, Flavor::FnDef)
 }
 
 // test param_list_opt_patterns
 // fn foo<F: FnMut(&mut Foo<'a>)>(){}
-pub(super) fn param_list_opt_patterns(p: &mut Parser) {
-    list_(p, Flavor::OptionalPattern)
+pub(super) fn param_list_fn_trait(p: &mut Parser) {
+    list_(p, Flavor::FnTrait)
 }
 
-pub(super) fn param_list_opt_types(p: &mut Parser) {
-    list_(p, Flavor::OptionalType)
+pub(super) fn param_list_fn_ptr(p: &mut Parser) {
+    list_(p, Flavor::FnPointer)
 }
 
-#[derive(Clone, Copy, Eq, PartialEq)]
-enum Flavor {
-    OptionalType,
-    OptionalPattern,
-    Normal,
+pub(super) fn param_list_closure(p: &mut Parser) {
+    list_(p, Flavor::Closure)
 }
 
-impl Flavor {
-    fn type_required(self) -> bool {
-        match self {
-            Flavor::OptionalType => false,
-            _ => true,
-        }
-    }
+#[derive(Debug, Clone, Copy)]
+enum Flavor {
+    FnDef,   // Includes trait fn params; omitted param idents are not supported
+    FnTrait, // Params for `Fn(...)`/`FnMut(...)`/`FnOnce(...)` annotations
+    FnPointer,
+    Closure,
 }
 
 fn list_(p: &mut Parser, flavor: Flavor) {
-    let (bra, ket) = if flavor.type_required() { (T!['('], T![')']) } else { (T![|], T![|]) };
-    assert!(p.at(bra));
+    use Flavor::*;
+
+    let (bra, ket) = match flavor {
+        Closure => (T![|], T![|]),
+        FnDef | FnTrait | FnPointer => (T!['('], T![')']),
+    };
+
     let m = p.start();
     p.bump(bra);
-    if flavor.type_required() {
+
+    if let FnDef = flavor {
         // test self_param_outer_attr
         // fn f(#[must_use] self) {}
         attributes::outer_attributes(p);
         opt_self_param(p);
     }
+
     while !p.at(EOF) && !p.at(ket) {
         // test param_outer_arg
         // fn f(#[attr1] pat: Type) {}
         attributes::outer_attributes(p);
 
-        if flavor.type_required() && p.at(T![...]) {
-            break;
+        // test param_list_vararg
+        // extern "C" { fn printf(format: *const i8, ...) -> i32; }
+        match flavor {
+            FnDef | FnPointer if p.eat(T![...]) => break,
+            _ => (),
         }
 
         if !p.at_ts(VALUE_PARAMETER_FIRST) {
@@ -66,11 +72,7 @@ fn list_(p: &mut Parser, flavor: Flavor) {
             p.expect(T![,]);
         }
     }
-    // test param_list_vararg
-    // extern "C" { fn printf(format: *const i8, ...) -> i32; }
-    if flavor.type_required() {
-        p.eat(T![...]);
-    }
+
     p.expect(ket);
     m.complete(p, PARAM_LIST);
 }
@@ -80,36 +82,56 @@ const VALUE_PARAMETER_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYP
 fn value_parameter(p: &mut Parser, flavor: Flavor) {
     let m = p.start();
     match flavor {
-        Flavor::OptionalType | Flavor::Normal => {
+        // test trait_fn_placeholder_parameter
+        // trait Foo {
+        //     fn bar(_: u64, mut x: i32);
+        // }
+
+        // test trait_fn_patterns
+        // trait T {
+        //     fn f1((a, b): (usize, usize)) {}
+        //     fn f2(S { a, b }: S) {}
+        //     fn f3(NewType(a): NewType) {}
+        //     fn f4(&&a: &&usize) {}
+        // }
+
+        // test fn_patterns
+        // impl U {
+        //     fn f1((a, b): (usize, usize)) {}
+        //     fn f2(S { a, b }: S) {}
+        //     fn f3(NewType(a): NewType) {}
+        //     fn f4(&&a: &&usize) {}
+        // }
+        Flavor::FnDef => {
             patterns::pattern(p);
-            if p.at(T![:]) && !p.at(T![::]) || flavor.type_required() {
-                types::ascription(p)
-            }
+            types::ascription(p);
         }
         // test value_parameters_no_patterns
-        // type F = Box<Fn(a: i32, &b: &i32, &mut c: &i32, ())>;
-        Flavor::OptionalPattern => {
-            let la0 = p.current();
-            let la1 = p.nth(1);
-            let la2 = p.nth(2);
-            let la3 = p.nth(3);
-
-            // test trait_fn_placeholder_parameter
-            // trait Foo {
-            //     fn bar(_: u64, mut x: i32);
-            // }
-            if (la0 == IDENT || la0 == T![_]) && la1 == T![:] && !p.nth_at(1, T![::])
-                || la0 == T![mut] && la1 == IDENT && la2 == T![:]
-                || la0 == T![&]
-                    && (la1 == IDENT && la2 == T![:] && !p.nth_at(2, T![::])
-                        || la1 == T![mut] && la2 == IDENT && la3 == T![:] && !p.nth_at(3, T![::]))
-            {
+        // type F = Box<Fn(i32, &i32, &i32, ())>;
+        Flavor::FnTrait => {
+            types::type_(p);
+        }
+        // test fn_pointer_param_ident_path
+        // type Foo = fn(Bar::Baz);
+        // type Qux = fn(baz: Bar::Baz);
+        Flavor::FnPointer => {
+            if p.at(IDENT) && p.nth(1) == T![:] && !p.nth_at(1, T![::]) {
                 patterns::pattern(p);
                 types::ascription(p);
             } else {
                 types::type_(p);
             }
         }
+        // test closure_params
+        // fn main() {
+        //    let foo = |bar, baz: Baz, qux: Qux::Quux| ();
+        // }
+        Flavor::Closure => {
+            patterns::pattern(p);
+            if p.at(T![:]) && !p.at(T![::]) {
+                types::ascription(p);
+            }
+        }
     }
     m.complete(p, PARAM);
 }
diff --git a/crates/ra_parser/src/grammar/paths.rs b/crates/ra_parser/src/grammar/paths.rs
index ca8e075a1..f5bf3d7ce 100644
--- a/crates/ra_parser/src/grammar/paths.rs
+++ b/crates/ra_parser/src/grammar/paths.rs
@@ -97,9 +97,9 @@ fn opt_path_type_args(p: &mut Parser, mode: Mode) {
         Mode::Use => return,
         Mode::Type => {
             // test path_fn_trait_args
-            // type F = Box<Fn(x: i32) -> ()>;
+            // type F = Box<Fn(i32) -> ()>;
             if p.at(T!['(']) {
-                params::param_list_opt_patterns(p);
+                params::param_list_fn_trait(p);
                 opt_fn_ret_type(p);
             } else {
                 type_args::opt_type_arg_list(p, false)
diff --git a/crates/ra_parser/src/grammar/types.rs b/crates/ra_parser/src/grammar/types.rs
index 9b2e440fb..2c00bce80 100644
--- a/crates/ra_parser/src/grammar/types.rs
+++ b/crates/ra_parser/src/grammar/types.rs
@@ -183,7 +183,7 @@ fn fn_pointer_type(p: &mut Parser) {
         return;
     }
     if p.at(T!['(']) {
-        params::param_list_opt_patterns(p);
+        params::param_list_fn_ptr(p);
     } else {
         p.error("expected parameters")
     }
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 4b301d67a..e27b27ffa 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 
 #![allow(bad_style, missing_docs, unreachable_pub)]
 #[doc = r" The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`."]
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index da541005a..d38ff397e 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -6,10 +6,9 @@ mod google_cpu_profiler;
 
 use std::{
     cell::RefCell,
+    collections::BTreeMap,
     collections::HashSet,
     io::{stderr, Write},
-    iter::repeat,
-    mem,
     sync::{
         atomic::{AtomicBool, Ordering},
         RwLock,
@@ -17,7 +16,6 @@ use std::{
     time::{Duration, Instant},
 };
 
-use itertools::Itertools;
 use once_cell::sync::Lazy;
 
 pub use crate::memory_usage::{Bytes, MemoryUsage};
@@ -51,6 +49,8 @@ pub fn set_filter(f: Filter) {
     *old = filter_data;
 }
 
+pub type Label = &'static str;
+
 /// This function starts a profiling scope in the current execution stack with a given description.
 /// It returns a Profile structure and measure elapsed time between this method invocation and Profile structure drop.
 /// It supports nested profiling scopes in case when this function invoked multiple times at the execution stack. In this case the profiling information will be nested at the output.
@@ -78,10 +78,10 @@ pub fn set_filter(f: Filter) {
 ///  0ms - profile
 ///      0ms - profile2
 /// ```
-pub fn profile(desc: &str) -> Profiler {
-    assert!(!desc.is_empty());
+pub fn profile(label: Label) -> Profiler {
+    assert!(!label.is_empty());
     if !PROFILING_ENABLED.load(Ordering::Relaxed) {
-        return Profiler { desc: None };
+        return Profiler { label: None };
     }
 
     PROFILE_STACK.with(|stack| {
@@ -94,20 +94,35 @@ pub fn profile(desc: &str) -> Profiler {
             };
         }
         if stack.starts.len() > stack.filter_data.depth {
-            return Profiler { desc: None };
+            return Profiler { label: None };
         }
         let allowed = &stack.filter_data.allowed;
-        if stack.starts.is_empty() && !allowed.is_empty() && !allowed.contains(desc) {
-            return Profiler { desc: None };
+        if stack.starts.is_empty() && !allowed.is_empty() && !allowed.contains(label) {
+            return Profiler { label: None };
         }
 
         stack.starts.push(Instant::now());
-        Profiler { desc: Some(desc.to_string()) }
+        Profiler { label: Some(label) }
     })
 }
 
+pub fn print_time(label: Label) -> impl Drop {
+    struct Guard {
+        label: Label,
+        start: Instant,
+    }
+
+    impl Drop for Guard {
+        fn drop(&mut self) {
+            eprintln!("{}: {:?}", self.label, self.start.elapsed())
+        }
+    }
+
+    Guard { label, start: Instant::now() }
+}
+
 pub struct Profiler {
-    desc: Option<String>,
+    label: Option<Label>,
 }
 
 pub struct Filter {
@@ -160,7 +175,7 @@ struct ProfileStack {
 struct Message {
     level: usize,
     duration: Duration,
-    message: String,
+    label: Label,
 }
 
 impl ProfileStack {
@@ -186,14 +201,13 @@ thread_local!(static PROFILE_STACK: RefCell<ProfileStack> = RefCell::new(Profile
 impl Drop for Profiler {
     fn drop(&mut self) {
         match self {
-            Profiler { desc: Some(desc) } => {
+            Profiler { label: Some(label) } => {
                 PROFILE_STACK.with(|stack| {
                     let mut stack = stack.borrow_mut();
                     let start = stack.starts.pop().unwrap();
                     let duration = start.elapsed();
                     let level = stack.starts.len();
-                    let message = mem::replace(desc, String::new());
-                    stack.messages.push(Message { level, duration, message });
+                    stack.messages.push(Message { level, duration, label: label });
                     if level == 0 {
                         let stdout = stderr();
                         let longer_than = stack.filter_data.longer_than;
@@ -201,70 +215,96 @@ impl Drop for Profiler {
                         // (otherwise we could print `0ms` despite user's `>0` filter when
                         // `duration` is just a few nanos).
                         if duration.as_millis() > longer_than.as_millis() {
-                            print(0, &stack.messages, &mut stdout.lock(), longer_than, None);
+                            print(&stack.messages, longer_than, &mut stdout.lock());
                         }
                         stack.messages.clear();
                     }
                 });
             }
-            Profiler { desc: None } => (),
+            Profiler { label: None } => (),
         }
     }
 }
 
-fn print(
-    lvl: usize,
-    msgs: &[Message],
-    out: &mut impl Write,
-    longer_than: Duration,
-    total: Option<Duration>,
-) {
+fn print(msgs: &[Message], longer_than: Duration, out: &mut impl Write) {
     if msgs.is_empty() {
         return;
     }
-    // The index of the first element that will be included in the slice when we recurse.
-    let mut next_start = 0;
-    let indent = repeat("    ").take(lvl).collect::<String>();
-    // We output hierarchy for long calls, but sum up all short calls
-    let mut short = Vec::new();
+    let children_map = idx_to_children(msgs);
+    let root_idx = msgs.len() - 1;
+    print_for_idx(root_idx, &children_map, msgs, longer_than, out);
+}
+
+fn print_for_idx(
+    current_idx: usize,
+    children_map: &[Vec<usize>],
+    msgs: &[Message],
+    longer_than: Duration,
+    out: &mut impl Write,
+) {
+    let current = &msgs[current_idx];
+    let current_indent = "    ".repeat(current.level);
+    writeln!(out, "{}{:5}ms - {}", current_indent, current.duration.as_millis(), current.label)
+        .expect("printing profiling info");
+
+    let longer_than_millis = longer_than.as_millis();
+    let children_indices = &children_map[current_idx];
     let mut accounted_for = Duration::default();
-    for (i, &Message { level, duration, message: ref msg }) in msgs.iter().enumerate() {
-        if level != lvl {
-            continue;
-        }
-        accounted_for += duration;
-        if duration.as_millis() > longer_than.as_millis() {
-            writeln!(out, "{}{:5}ms - {}", indent, duration.as_millis(), msg)
-                .expect("printing profiling info to stdout");
+    let mut short_children = BTreeMap::new(); // Use `BTreeMap` to get deterministic output.
 
-            print(lvl + 1, &msgs[next_start..i], out, longer_than, Some(duration));
+    for child_idx in children_indices.iter() {
+        let child = &msgs[*child_idx];
+        if child.duration.as_millis() > longer_than_millis {
+            print_for_idx(*child_idx, children_map, msgs, longer_than, out);
         } else {
-            short.push((msg, duration))
+            let pair = short_children.entry(child.label).or_insert((Duration::default(), 0));
+            pair.0 += child.duration;
+            pair.1 += 1;
         }
+        accounted_for += child.duration;
+    }
 
-        next_start = i + 1;
+    for (child_msg, (duration, count)) in short_children.iter() {
+        let millis = duration.as_millis();
+        writeln!(out, "    {}{:5}ms - {} ({} calls)", current_indent, millis, child_msg, count)
+            .expect("printing profiling info");
     }
-    short.sort_by_key(|(msg, _time)| *msg);
-    for (msg, entires) in short.iter().group_by(|(msg, _time)| msg).into_iter() {
-        let mut count = 0;
-        let mut total_duration = Duration::default();
-        entires.for_each(|(_msg, time)| {
-            count += 1;
-            total_duration += *time;
-        });
-        writeln!(out, "{}{:5}ms - {} ({} calls)", indent, total_duration.as_millis(), msg, count)
-            .expect("printing profiling info to stdout");
+
+    let unaccounted_millis = (current.duration - accounted_for).as_millis();
+    if !children_indices.is_empty()
+        && unaccounted_millis > 0
+        && unaccounted_millis > longer_than_millis
+    {
+        writeln!(out, "    {}{:5}ms - ???", current_indent, unaccounted_millis)
+            .expect("printing profiling info");
     }
+}
 
-    if let Some(total) = total {
-        if let Some(unaccounted) = total.checked_sub(accounted_for) {
-            let unaccounted_millis = unaccounted.as_millis();
-            if unaccounted_millis > longer_than.as_millis() && unaccounted_millis > 0 {
-                writeln!(out, "{}{:5}ms - ???", indent, unaccounted_millis)
-                    .expect("printing profiling info to stdout");
-            }
+/// Returns a mapping from an index in the `msgs` to the vector with the indices of its children.
+///
+/// This assumes that the entries in `msgs` are in the order of when the calls to `profile` finish.
+/// In other words, a postorder of the call graph. In particular, the root is the last element of
+/// `msgs`.
+fn idx_to_children(msgs: &[Message]) -> Vec<Vec<usize>> {
+    // Initialize with the index of the root; `msgs` and `ancestors` should be never empty.
+    assert!(!msgs.is_empty());
+    let mut ancestors = vec![msgs.len() - 1];
+    let mut result: Vec<Vec<usize>> = vec![vec![]; msgs.len()];
+    for (idx, msg) in msgs[..msgs.len() - 1].iter().enumerate().rev() {
+        // We need to find the parent of the current message, i.e., the last ancestor that has a
+        // level lower than the current message.
+        while msgs[*ancestors.last().unwrap()].level >= msg.level {
+            ancestors.pop();
         }
+        result[*ancestors.last().unwrap()].push(idx);
+        ancestors.push(idx);
+    }
+    // Note that above we visited all children from the last to the first one. Let's reverse vectors
+    // to get the more natural order where the first element is the first child.
+    for vec in result.iter_mut() {
+        vec.reverse();
     }
+    result
 }
 
 /// Prints backtrace to stderr, useful for debugging.
@@ -369,11 +409,11 @@ mod tests {
     fn test_longer_than() {
         let mut result = vec![];
         let msgs = vec![
-            Message { level: 1, duration: Duration::from_nanos(3), message: "bar".to_owned() },
-            Message { level: 1, duration: Duration::from_nanos(2), message: "bar".to_owned() },
-            Message { level: 0, duration: Duration::from_millis(1), message: "foo".to_owned() },
+            Message { level: 1, duration: Duration::from_nanos(3), label: "bar" },
+            Message { level: 1, duration: Duration::from_nanos(2), label: "bar" },
+            Message { level: 0, duration: Duration::from_millis(1), label: "foo" },
         ];
-        print(0, &msgs, &mut result, Duration::from_millis(0), Some(Duration::from_millis(1)));
+        print(&msgs, Duration::from_millis(0), &mut result);
         // The calls to `bar` are so short that they'll be rounded to 0ms and should get collapsed
         // when printing.
         assert_eq!(
@@ -386,10 +426,10 @@ mod tests {
     fn test_unaccounted_for_topmost() {
         let mut result = vec![];
         let msgs = vec![
-            Message { level: 1, duration: Duration::from_millis(2), message: "bar".to_owned() },
-            Message { level: 0, duration: Duration::from_millis(5), message: "foo".to_owned() },
+            Message { level: 1, duration: Duration::from_millis(2), label: "bar" },
+            Message { level: 0, duration: Duration::from_millis(5), label: "foo" },
         ];
-        print(0, &msgs, &mut result, Duration::from_millis(0), Some(Duration::from_millis(1)));
+        print(&msgs, Duration::from_millis(0), &mut result);
         assert_eq!(
             std::str::from_utf8(&result).unwrap().lines().collect::<Vec<_>>(),
             vec![
@@ -405,13 +445,13 @@ mod tests {
     fn test_unaccounted_for_multiple_levels() {
         let mut result = vec![];
         let msgs = vec![
-            Message { level: 2, duration: Duration::from_millis(3), message: "baz".to_owned() },
-            Message { level: 1, duration: Duration::from_millis(5), message: "bar".to_owned() },
-            Message { level: 2, duration: Duration::from_millis(2), message: "baz".to_owned() },
-            Message { level: 1, duration: Duration::from_millis(4), message: "bar".to_owned() },
-            Message { level: 0, duration: Duration::from_millis(9), message: "foo".to_owned() },
+            Message { level: 2, duration: Duration::from_millis(3), label: "baz" },
+            Message { level: 1, duration: Duration::from_millis(5), label: "bar" },
+            Message { level: 2, duration: Duration::from_millis(2), label: "baz" },
+            Message { level: 1, duration: Duration::from_millis(4), label: "bar" },
+            Message { level: 0, duration: Duration::from_millis(9), label: "foo" },
         ];
-        print(0, &msgs, &mut result, Duration::from_millis(0), None);
+        print(&msgs, Duration::from_millis(0), &mut result);
         assert_eq!(
             std::str::from_utf8(&result).unwrap().lines().collect::<Vec<_>>(),
             vec![
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 1832c101f..60cb8c1eb 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -207,9 +207,28 @@ impl CargoWorkspace {
         }
         let resolve = meta.resolve.expect("metadata executed with deps");
         for node in resolve.nodes {
-            let source = pkg_by_id[&node.id];
+            let source = match pkg_by_id.get(&node.id) {
+                Some(&src) => src,
+                // FIXME: replace this and a similar branch below with `.unwrap`, once
+                // https://github.com/rust-lang/cargo/issues/7841
+                // is fixed and hits stable (around 1.43-is probably?).
+                None => {
+                    log::error!("Node id do not match in cargo metadata, ignoring {}", node.id);
+                    continue;
+                }
+            };
             for dep_node in node.deps {
-                let dep = PackageDependency { name: dep_node.name, pkg: pkg_by_id[&dep_node.pkg] };
+                let pkg = match pkg_by_id.get(&dep_node.pkg) {
+                    Some(&pkg) => pkg,
+                    None => {
+                        log::error!(
+                            "Dep node id do not match in cargo metadata, ignoring {}",
+                            dep_node.pkg
+                        );
+                        continue;
+                    }
+                };
+                let dep = PackageDependency { name: dep_node.name, pkg };
                 packages[source].dependencies.push(dep);
             }
             packages[source].features.extend(node.features);
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 6a104e6f2..bc1d15406 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -13,7 +13,7 @@ use std::{
 };
 
 use ra_cfg::CfgOptions;
-use ra_db::{CrateGraph, CrateId, Edition, Env, FileId};
+use ra_db::{CrateGraph, CrateId, CrateName, Edition, Env, FileId};
 use rustc_hash::FxHashMap;
 use serde_json::from_reader;
 
@@ -177,7 +177,9 @@ impl ProjectWorkspace {
                         if let (Some(&from), Some(&to)) =
                             (crates.get(&from_crate_id), crates.get(&to_crate_id))
                         {
-                            if let Err(_) = crate_graph.add_dep(from, dep.name.clone().into(), to) {
+                            if let Err(_) =
+                                crate_graph.add_dep(from, CrateName::new(&dep.name).unwrap(), to)
+                            {
                                 log::error!(
                                     "cyclic dependency {:?} -> {:?}",
                                     from_crate_id,
@@ -215,7 +217,9 @@ impl ProjectWorkspace {
                         if let (Some(&from), Some(&to)) =
                             (sysroot_crates.get(&from), sysroot_crates.get(&to))
                         {
-                            if let Err(_) = crate_graph.add_dep(from, name.into(), to) {
+                            if let Err(_) =
+                                crate_graph.add_dep(from, CrateName::new(name).unwrap(), to)
+                            {
                                 log::error!("cyclic dependency between sysroot crates")
                             }
                         }
@@ -257,7 +261,7 @@ impl ProjectWorkspace {
                                 if let Some(proc_macro) = libproc_macro {
                                     if let Err(_) = crate_graph.add_dep(
                                         crate_id,
-                                        "proc_macro".into(),
+                                        CrateName::new("proc_macro").unwrap(),
                                         proc_macro,
                                     ) {
                                         log::error!(
@@ -276,9 +280,14 @@ impl ProjectWorkspace {
                     for &from in pkg_crates.get(&pkg).into_iter().flatten() {
                         if let Some(to) = lib_tgt {
                             if to != from {
-                                if let Err(_) =
-                                    crate_graph.add_dep(from, pkg.name(&cargo).into(), to)
-                                {
+                                if let Err(_) = crate_graph.add_dep(
+                                    from,
+                                    // For root projects with dashes in their name,
+                                    // cargo metadata does not do any normalization,
+                                    // so we do it ourselves currently
+                                    CrateName::normalize_dashes(pkg.name(&cargo)),
+                                    to,
+                                ) {
                                     log::error!(
                                         "cyclic dependency between targets of {}",
                                         pkg.name(&cargo)
@@ -289,17 +298,23 @@ impl ProjectWorkspace {
                         // core is added as a dependency before std in order to
                         // mimic rustcs dependency order
                         if let Some(core) = libcore {
-                            if let Err(_) = crate_graph.add_dep(from, "core".into(), core) {
+                            if let Err(_) =
+                                crate_graph.add_dep(from, CrateName::new("core").unwrap(), core)
+                            {
                                 log::error!("cyclic dependency on core for {}", pkg.name(&cargo))
                             }
                         }
                         if let Some(alloc) = liballoc {
-                            if let Err(_) = crate_graph.add_dep(from, "alloc".into(), alloc) {
+                            if let Err(_) =
+                                crate_graph.add_dep(from, CrateName::new("alloc").unwrap(), alloc)
+                            {
                                 log::error!("cyclic dependency on alloc for {}", pkg.name(&cargo))
                             }
                         }
                         if let Some(std) = libstd {
-                            if let Err(_) = crate_graph.add_dep(from, "std".into(), std) {
+                            if let Err(_) =
+                                crate_graph.add_dep(from, CrateName::new("std").unwrap(), std)
+                            {
                                 log::error!("cyclic dependency on std for {}", pkg.name(&cargo))
                             }
                         }
@@ -312,9 +327,11 @@ impl ProjectWorkspace {
                     for dep in pkg.dependencies(&cargo) {
                         if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
                             for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                                if let Err(_) =
-                                    crate_graph.add_dep(from, dep.name.clone().into(), to)
-                                {
+                                if let Err(_) = crate_graph.add_dep(
+                                    from,
+                                    CrateName::new(&dep.name).unwrap(),
+                                    to,
+                                ) {
                                     log::error!(
                                         "cyclic dependency {} -> {}",
                                         pkg.name(&cargo),
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index c5a3d1999..83db943fe 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -4,7 +4,7 @@ name = "ra_syntax"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 license = "MIT OR Apache-2.0"
-description = "Comment and whitespace preserving parser for the Rust langauge"
+description = "Comment and whitespace preserving parser for the Rust language"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 
 [lib]
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 30a479f01..acf677e7d 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -81,7 +81,7 @@ impl TreeDiff {
 /// Specifically, returns a map whose keys are descendants of `from` and values
 /// are descendants of `to`, such that  `replace_descendants(from, map) == to`.
 ///
-/// A trivial solution is a singletom map `{ from: to }`, but this function
+/// A trivial solution is a singleton map `{ from: to }`, but this function
 /// tries to find a more fine-grained diff.
 pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
     let mut buf = FxHashMap::default();
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 539759450..2e50a095c 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -7,6 +7,21 @@ use crate::{
     SyntaxToken, T,
 };
 
+impl ast::Expr {
+    pub fn is_block_like(&self) -> bool {
+        match self {
+            ast::Expr::IfExpr(_)
+            | ast::Expr::LoopExpr(_)
+            | ast::Expr::ForExpr(_)
+            | ast::Expr::WhileExpr(_)
+            | ast::Expr::BlockExpr(_)
+            | ast::Expr::MatchExpr(_)
+            | ast::Expr::TryBlockExpr(_) => true,
+            _ => false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ElseBranch {
     Block(ast::BlockExpr),
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 33d5578e7..435135f92 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 
 use crate::{
     ast::{self, AstChildren, AstNode},
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 36e648180..862eb1172 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -2,7 +2,7 @@
 //! of smaller pieces.
 use itertools::Itertools;
 
-use crate::{ast, AstNode, SourceFile, SyntaxKind, SyntaxToken};
+use crate::{ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, SyntaxToken};
 
 pub fn name(text: &str) -> ast::Name {
     ast_from_text(&format!("mod {};", text))
@@ -33,6 +33,21 @@ pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordF
     }
 }
 
+pub fn block_expr(
+    stmts: impl IntoIterator<Item = ast::Stmt>,
+    tail_expr: Option<ast::Expr>,
+) -> ast::BlockExpr {
+    let mut text = "{\n".to_string();
+    for stmt in stmts.into_iter() {
+        text += &format!("    {}\n", stmt.syntax());
+    }
+    if let Some(tail_expr) = tail_expr {
+        text += &format!("    {}\n", tail_expr.syntax())
+    }
+    text += "}";
+    ast_from_text(&format!("fn f() {}", text))
+}
+
 pub fn block_from_expr(e: ast::Expr) -> ast::Block {
     return from_text(&format!("{{ {} }}", e.syntax()));
 
@@ -62,6 +77,13 @@ pub fn expr_return() -> ast::Expr {
 pub fn expr_match(expr: ast::Expr, match_arm_list: ast::MatchArmList) -> ast::Expr {
     expr_from_text(&format!("match {} {}", expr.syntax(), match_arm_list.syntax()))
 }
+pub fn expr_if(condition: ast::Expr, then_branch: ast::BlockExpr) -> ast::Expr {
+    expr_from_text(&format!("if {} {}", condition.syntax(), then_branch.syntax()))
+}
+pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr {
+    let token = token(op);
+    expr_from_text(&format!("{}{}", token, expr.syntax()))
+}
 fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }
@@ -122,11 +144,18 @@ pub fn match_arm(pats: impl IntoIterator<Item = ast::Pat>, expr: ast::Expr) -> a
 }
 
 pub fn match_arm_list(arms: impl IntoIterator<Item = ast::MatchArm>) -> ast::MatchArmList {
-    let arms_str = arms.into_iter().map(|arm| format!("\n    {}", arm.syntax())).join(",");
-    return from_text(&format!("{},\n", arms_str));
+    let arms_str = arms
+        .into_iter()
+        .map(|arm| {
+            let needs_comma = arm.expr().map_or(true, |it| !it.is_block_like());
+            let comma = if needs_comma { "," } else { "" };
+            format!("    {}{}\n", arm.syntax(), comma)
+        })
+        .collect::<String>();
+    return from_text(&format!("{}", arms_str));
 
     fn from_text(text: &str) -> ast::MatchArmList {
-        ast_from_text(&format!("fn f() {{ match () {{{}}} }}", text))
+        ast_from_text(&format!("fn f() {{ match () {{\n{}}} }}", text))
     }
 }
 
@@ -151,14 +180,6 @@ pub fn where_clause(preds: impl IntoIterator<Item = ast::WherePred>) -> ast::Whe
     }
 }
 
-pub fn if_expression(condition: &ast::Expr, statement: &str) -> ast::IfExpr {
-    ast_from_text(&format!(
-        "fn f() {{ if !{} {{\n    {}\n}}\n}}",
-        condition.syntax().text(),
-        statement
-    ))
-}
-
 pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetStmt {
     let text = match initializer {
         Some(it) => format!("let {} = {};", pattern.syntax(), it.syntax()),
@@ -166,6 +187,9 @@ pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetSt
     };
     ast_from_text(&format!("fn f() {{ {} }}", text))
 }
+pub fn expr_stmt(expr: ast::Expr) -> ast::ExprStmt {
+    ast_from_text(&format!("fn f() {{ {}; }}", expr.syntax()))
+}
 
 pub fn token(kind: SyntaxKind) -> SyntaxToken {
     tokens::SOURCE_FILE
@@ -179,7 +203,16 @@ pub fn token(kind: SyntaxKind) -> SyntaxToken {
 
 fn ast_from_text<N: AstNode>(text: &str) -> N {
     let parse = SourceFile::parse(text);
-    parse.tree().syntax().descendants().find_map(N::cast).unwrap()
+    let node = parse.tree().syntax().descendants().find_map(N::cast).unwrap();
+    let node = node.syntax().clone();
+    let node = unroot(node);
+    let node = N::cast(node).unwrap();
+    assert_eq!(node.syntax().text_range().start(), 0.into());
+    node
+}
+
+fn unroot(n: SyntaxNode) -> SyntaxNode {
+    SyntaxNode::new_root(n.green().clone())
 }
 
 pub mod tokens {
@@ -187,7 +220,7 @@ pub mod tokens {
     use once_cell::sync::Lazy;
 
     pub(super) static SOURCE_FILE: Lazy<Parse<SourceFile>> =
-        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2)\n;"));
+        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2, !true)\n;"));
 
     pub fn comma() -> SyntaxToken {
         SOURCE_FILE
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 9931fec84..f8f4b64c1 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -41,7 +41,9 @@ use crate::syntax_node::GreenNode;
 pub use crate::{
     algo::InsertPosition,
     ast::{AstNode, AstToken},
-    parsing::{classify_literal, tokenize, Token},
+    parsing::{
+        lex_single_syntax_kind, lex_single_valid_syntax_kind, tokenize, Token, TokenizeError,
+    },
     ptr::{AstPtr, SyntaxNodePtr},
     syntax_error::{Location, SyntaxError, SyntaxErrorKind},
     syntax_node::{
diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs
index 0387f0378..e5eb80850 100644
--- a/crates/ra_syntax/src/parsing.rs
+++ b/crates/ra_syntax/src/parsing.rs
@@ -7,15 +7,23 @@ mod text_tree_sink;
 mod reparsing;
 
 use crate::{syntax_node::GreenNode, SyntaxError};
+use text_token_source::TextTokenSource;
+use text_tree_sink::TextTreeSink;
 
-pub use self::lexer::{classify_literal, tokenize, Token};
+pub use lexer::*;
 
 pub(crate) use self::reparsing::incremental_reparse;
 
 pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
-    let tokens = tokenize(&text);
-    let mut token_source = text_token_source::TextTokenSource::new(text, &tokens);
-    let mut tree_sink = text_tree_sink::TextTreeSink::new(text, &tokens);
+    let (tokens, lexer_errors) = tokenize(&text);
+
+    let mut token_source = TextTokenSource::new(text, &tokens);
+    let mut tree_sink = TextTreeSink::new(text, &tokens);
+
     ra_parser::parse(&mut token_source, &mut tree_sink);
-    tree_sink.finish()
+
+    let (tree, mut parser_errors) = tree_sink.finish();
+    parser_errors.extend(lexer_errors);
+
+    (tree, parser_errors)
 }
diff --git a/crates/ra_syntax/src/parsing/lexer.rs b/crates/ra_syntax/src/parsing/lexer.rs
index 6d839208d..f889e6a1d 100644
--- a/crates/ra_syntax/src/parsing/lexer.rs
+++ b/crates/ra_syntax/src/parsing/lexer.rs
@@ -1,8 +1,10 @@
-//! FIXME: write short doc here
+//! Lexer analyzes raw input string and produces lexemes (tokens).
+//! It is just a bridge to `rustc_lexer`.
 
 use crate::{
+    SyntaxError, SyntaxErrorKind,
     SyntaxKind::{self, *},
-    TextUnit,
+    TextRange, TextUnit,
 };
 
 /// A token of Rust source.
@@ -14,91 +16,261 @@ pub struct Token {
     pub len: TextUnit,
 }
 
-fn match_literal_kind(kind: rustc_lexer::LiteralKind) -> SyntaxKind {
-    match kind {
-        rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
-        rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
-        rustc_lexer::LiteralKind::Char { .. } => CHAR,
-        rustc_lexer::LiteralKind::Byte { .. } => BYTE,
-        rustc_lexer::LiteralKind::Str { .. } => STRING,
-        rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
-        rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
-        rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
+/// Break a string up into its component tokens.
+/// Beware that it checks for shebang first and its length contributes to resulting
+/// tokens offsets.
+pub fn tokenize(text: &str) -> (Vec<Token>, Vec<SyntaxError>) {
+    // non-empty string is a precondtion of `rustc_lexer::strip_shebang()`.
+    if text.is_empty() {
+        return Default::default();
+    }
+
+    let mut tokens = Vec::new();
+    let mut errors = Vec::new();
+
+    let mut offset: usize = rustc_lexer::strip_shebang(text)
+        .map(|shebang_len| {
+            tokens.push(Token { kind: SHEBANG, len: TextUnit::from_usize(shebang_len) });
+            shebang_len
+        })
+        .unwrap_or(0);
+
+    let text_without_shebang = &text[offset..];
+
+    for rustc_token in rustc_lexer::tokenize(text_without_shebang) {
+        let token_len = TextUnit::from_usize(rustc_token.len);
+        let token_range = TextRange::offset_len(TextUnit::from_usize(offset), token_len);
+
+        let (syntax_kind, error) =
+            rustc_token_kind_to_syntax_kind(&rustc_token.kind, &text[token_range]);
+
+        tokens.push(Token { kind: syntax_kind, len: token_len });
+
+        if let Some(error) = error {
+            errors.push(SyntaxError::new(SyntaxErrorKind::TokenizeError(error), token_range));
+        }
+
+        offset += rustc_token.len;
     }
+
+    (tokens, errors)
+}
+
+/// Returns `SyntaxKind` and `Option<SyntaxError>` of the first token
+/// encountered at the beginning of the string.
+///
+/// Returns `None` if the string contains zero *or two or more* tokens.
+/// The token is malformed if the returned error is not `None`.
+///
+/// Beware that unescape errors are not checked at tokenization time.
+pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxError>)> {
+    lex_first_token(text)
+        .filter(|(token, _)| token.len.to_usize() == text.len())
+        .map(|(token, error)| (token.kind, error))
+}
+
+/// The same as `lex_single_syntax_kind()` but returns only `SyntaxKind` and
+/// returns `None` if any tokenization error occured.
+///
+/// Beware that unescape errors are not checked at tokenization time.
+pub fn lex_single_valid_syntax_kind(text: &str) -> Option<SyntaxKind> {
+    lex_first_token(text)
+        .filter(|(token, error)| !error.is_some() && token.len.to_usize() == text.len())
+        .map(|(token, _error)| token.kind)
 }
 
-/// Break a string up into its component tokens
-pub fn tokenize(text: &str) -> Vec<Token> {
+/// Returns `SyntaxKind` and `Option<SyntaxError>` of the first token
+/// encountered at the beginning of the string.
+///
+/// Returns `None` if the string contains zero tokens or if the token was parsed
+/// with an error.
+/// The token is malformed if the returned error is not `None`.
+///
+/// Beware that unescape errors are not checked at tokenization time.
+fn lex_first_token(text: &str) -> Option<(Token, Option<SyntaxError>)> {
+    // non-empty string is a precondtion of `rustc_lexer::first_token()`.
     if text.is_empty() {
-        return vec![];
-    }
-    let mut text = text;
-    let mut acc = Vec::new();
-    if let Some(len) = rustc_lexer::strip_shebang(text) {
-        acc.push(Token { kind: SHEBANG, len: TextUnit::from_usize(len) });
-        text = &text[len..];
+        return None;
     }
-    while !text.is_empty() {
-        let rustc_token = rustc_lexer::first_token(text);
-        let kind = match rustc_token.kind {
-            rustc_lexer::TokenKind::LineComment => COMMENT,
-            rustc_lexer::TokenKind::BlockComment { .. } => COMMENT,
-            rustc_lexer::TokenKind::Whitespace => WHITESPACE,
-            rustc_lexer::TokenKind::Ident => {
-                let token_text = &text[..rustc_token.len];
+
+    let rustc_token = rustc_lexer::first_token(text);
+    let (syntax_kind, error) = rustc_token_kind_to_syntax_kind(&rustc_token.kind, text);
+
+    let token = Token { kind: syntax_kind, len: TextUnit::from_usize(rustc_token.len) };
+    let error = error.map(|error| {
+        SyntaxError::new(
+            SyntaxErrorKind::TokenizeError(error),
+            TextRange::from_to(TextUnit::from(0), TextUnit::of_str(text)),
+        )
+    });
+
+    Some((token, error))
+}
+
+// FIXME: simplify TokenizeError to `SyntaxError(String, TextRange)` as per @matklad advice:
+// https://github.com/rust-analyzer/rust-analyzer/pull/2911/files#r371175067
+
+/// Describes the values of `SyntaxErrorKind::TokenizeError` enum variant.
+/// It describes all the types of errors that may happen during the tokenization
+/// of Rust source.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum TokenizeError {
+    /// Base prefix was provided, but there were no digits
+    /// after it, e.g. `0x`, `0b`.
+    EmptyInt,
+    /// Float exponent lacks digits e.g. `12.34e+`, `12.3E+`, `12e-`, `1_E-`,
+    EmptyExponent,
+
+    /// Block comment lacks trailing delimiter `*/`
+    UnterminatedBlockComment,
+    /// Character literal lacks trailing delimiter `'`
+    UnterminatedChar,
+    /// Characterish byte literal lacks trailing delimiter `'`
+    UnterminatedByte,
+    /// String literal lacks trailing delimiter `"`
+    UnterminatedString,
+    /// Byte string literal lacks trailing delimiter `"`
+    UnterminatedByteString,
+    /// Raw literal lacks trailing delimiter e.g. `"##`
+    UnterminatedRawString,
+    /// Raw byte string literal lacks trailing delimiter e.g. `"##`
+    UnterminatedRawByteString,
+
+    /// Raw string lacks a quote after the pound characters e.g. `r###`
+    UnstartedRawString,
+    /// Raw byte string lacks a quote after the pound characters e.g. `br###`
+    UnstartedRawByteString,
+
+    /// Lifetime starts with a number e.g. `'4ever`
+    LifetimeStartsWithNumber,
+}
+
+fn rustc_token_kind_to_syntax_kind(
+    rustc_token_kind: &rustc_lexer::TokenKind,
+    token_text: &str,
+) -> (SyntaxKind, Option<TokenizeError>) {
+    // A note on an intended tradeoff:
+    // We drop some useful infromation here (see patterns with double dots `..`)
+    // Storing that info in `SyntaxKind` is not possible due to its layout requirements of
+    // being `u16` that come from `rowan::SyntaxKind`.
+
+    let syntax_kind = {
+        use rustc_lexer::TokenKind as TK;
+        use TokenizeError as TE;
+
+        match rustc_token_kind {
+            TK::LineComment => COMMENT,
+
+            TK::BlockComment { terminated: true } => COMMENT,
+            TK::BlockComment { terminated: false } => {
+                return (COMMENT, Some(TE::UnterminatedBlockComment));
+            }
+
+            TK::Whitespace => WHITESPACE,
+
+            TK::Ident => {
                 if token_text == "_" {
                     UNDERSCORE
                 } else {
-                    SyntaxKind::from_keyword(&text[..rustc_token.len]).unwrap_or(IDENT)
+                    SyntaxKind::from_keyword(token_text).unwrap_or(IDENT)
                 }
             }
-            rustc_lexer::TokenKind::RawIdent => IDENT,
-            rustc_lexer::TokenKind::Literal { kind, .. } => match_literal_kind(kind),
-            rustc_lexer::TokenKind::Lifetime { .. } => LIFETIME,
-            rustc_lexer::TokenKind::Semi => SEMI,
-            rustc_lexer::TokenKind::Comma => COMMA,
-            rustc_lexer::TokenKind::Dot => DOT,
-            rustc_lexer::TokenKind::OpenParen => L_PAREN,
-            rustc_lexer::TokenKind::CloseParen => R_PAREN,
-            rustc_lexer::TokenKind::OpenBrace => L_CURLY,
-            rustc_lexer::TokenKind::CloseBrace => R_CURLY,
-            rustc_lexer::TokenKind::OpenBracket => L_BRACK,
-            rustc_lexer::TokenKind::CloseBracket => R_BRACK,
-            rustc_lexer::TokenKind::At => AT,
-            rustc_lexer::TokenKind::Pound => POUND,
-            rustc_lexer::TokenKind::Tilde => TILDE,
-            rustc_lexer::TokenKind::Question => QUESTION,
-            rustc_lexer::TokenKind::Colon => COLON,
-            rustc_lexer::TokenKind::Dollar => DOLLAR,
-            rustc_lexer::TokenKind::Eq => EQ,
-            rustc_lexer::TokenKind::Not => EXCL,
-            rustc_lexer::TokenKind::Lt => L_ANGLE,
-            rustc_lexer::TokenKind::Gt => R_ANGLE,
-            rustc_lexer::TokenKind::Minus => MINUS,
-            rustc_lexer::TokenKind::And => AMP,
-            rustc_lexer::TokenKind::Or => PIPE,
-            rustc_lexer::TokenKind::Plus => PLUS,
-            rustc_lexer::TokenKind::Star => STAR,
-            rustc_lexer::TokenKind::Slash => SLASH,
-            rustc_lexer::TokenKind::Caret => CARET,
-            rustc_lexer::TokenKind::Percent => PERCENT,
-            rustc_lexer::TokenKind::Unknown => ERROR,
+
+            TK::RawIdent => IDENT,
+            TK::Literal { kind, .. } => return match_literal_kind(&kind),
+
+            TK::Lifetime { starts_with_number: false } => LIFETIME,
+            TK::Lifetime { starts_with_number: true } => {
+                return (LIFETIME, Some(TE::LifetimeStartsWithNumber))
+            }
+
+            TK::Semi => SEMI,
+            TK::Comma => COMMA,
+            TK::Dot => DOT,
+            TK::OpenParen => L_PAREN,
+            TK::CloseParen => R_PAREN,
+            TK::OpenBrace => L_CURLY,
+            TK::CloseBrace => R_CURLY,
+            TK::OpenBracket => L_BRACK,
+            TK::CloseBracket => R_BRACK,
+            TK::At => AT,
+            TK::Pound => POUND,
+            TK::Tilde => TILDE,
+            TK::Question => QUESTION,
+            TK::Colon => COLON,
+            TK::Dollar => DOLLAR,
+            TK::Eq => EQ,
+            TK::Not => EXCL,
+            TK::Lt => L_ANGLE,
+            TK::Gt => R_ANGLE,
+            TK::Minus => MINUS,
+            TK::And => AMP,
+            TK::Or => PIPE,
+            TK::Plus => PLUS,
+            TK::Star => STAR,
+            TK::Slash => SLASH,
+            TK::Caret => CARET,
+            TK::Percent => PERCENT,
+            TK::Unknown => ERROR,
+        }
+    };
+
+    return (syntax_kind, None);
+
+    fn match_literal_kind(kind: &rustc_lexer::LiteralKind) -> (SyntaxKind, Option<TokenizeError>) {
+        use rustc_lexer::LiteralKind as LK;
+        use TokenizeError as TE;
+
+        #[rustfmt::skip]
+        let syntax_kind = match *kind {
+            LK::Int { empty_int: false, .. } => INT_NUMBER,
+            LK::Int { empty_int: true, .. } => {
+                return (INT_NUMBER, Some(TE::EmptyInt))
+            }
+
+            LK::Float { empty_exponent: false, .. } => FLOAT_NUMBER,
+            LK::Float { empty_exponent: true, .. } => {
+                return (FLOAT_NUMBER, Some(TE::EmptyExponent))
+            }
+
+            LK::Char { terminated: true } => CHAR,
+            LK::Char { terminated: false } => {
+                return (CHAR, Some(TE::UnterminatedChar))
+            }
+
+            LK::Byte { terminated: true } => BYTE,
+            LK::Byte { terminated: false } => {
+                return (BYTE, Some(TE::UnterminatedByte))
+            }
+
+            LK::Str { terminated: true } => STRING,
+            LK::Str { terminated: false } => {
+                return (STRING, Some(TE::UnterminatedString))
+            }
+
+
+            LK::ByteStr { terminated: true } => BYTE_STRING,
+            LK::ByteStr { terminated: false } => {
+                return (BYTE_STRING, Some(TE::UnterminatedByteString))
+            }
+
+            LK::RawStr { started: true, terminated: true, .. } => RAW_STRING,
+            LK::RawStr { started: true, terminated: false, .. } => {
+                return (RAW_STRING, Some(TE::UnterminatedRawString))
+            }
+            LK::RawStr { started: false, .. } => {
+                return (RAW_STRING, Some(TE::UnstartedRawString))
+            }
+
+            LK::RawByteStr { started: true, terminated: true, .. } => RAW_BYTE_STRING,
+            LK::RawByteStr { started: true, terminated: false, .. } => {
+                return (RAW_BYTE_STRING, Some(TE::UnterminatedRawByteString))
+            }
+            LK::RawByteStr { started: false, .. } => {
+                return (RAW_BYTE_STRING, Some(TE::UnstartedRawByteString))
+            }
         };
-        let token = Token { kind, len: TextUnit::from_usize(rustc_token.len) };
-        acc.push(token);
-        text = &text[rustc_token.len..];
-    }
-    acc
-}
 
-pub fn classify_literal(text: &str) -> Option<Token> {
-    let t = rustc_lexer::first_token(text);
-    if t.len != text.len() {
-        return None;
+        (syntax_kind, None)
     }
-    let kind = match t.kind {
-        rustc_lexer::TokenKind::Literal { kind, .. } => match_literal_kind(kind),
-        _ => return None,
-    };
-    Some(Token { kind, len: TextUnit::from_usize(t.len) })
 }
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index 06bdda11d..a86da0675 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -12,7 +12,7 @@ use ra_text_edit::AtomTextEdit;
 use crate::{
     algo,
     parsing::{
-        lexer::{tokenize, Token},
+        lexer::{lex_single_syntax_kind, tokenize, Token},
         text_token_source::TextTokenSource,
         text_tree_sink::TextTreeSink,
     },
@@ -41,37 +41,42 @@ fn reparse_token<'node>(
     root: &'node SyntaxNode,
     edit: &AtomTextEdit,
 ) -> Option<(GreenNode, TextRange)> {
-    let token = algo::find_covering_element(root, edit.delete).as_token()?.clone();
-    match token.kind() {
+    let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone();
+    let prev_token_kind = prev_token.kind();
+    match prev_token_kind {
         WHITESPACE | COMMENT | IDENT | STRING | RAW_STRING => {
-            if token.kind() == WHITESPACE || token.kind() == COMMENT {
+            if prev_token_kind == WHITESPACE || prev_token_kind == COMMENT {
                 // removing a new line may extends previous token
-                if token.text().to_string()[edit.delete - token.text_range().start()].contains('\n')
-                {
+                let deleted_range = edit.delete - prev_token.text_range().start();
+                if prev_token.text()[deleted_range].contains('\n') {
                     return None;
                 }
             }
 
-            let text = get_text_after_edit(token.clone().into(), &edit);
-            let lex_tokens = tokenize(&text);
-            let lex_token = match lex_tokens[..] {
-                [lex_token] if lex_token.kind == token.kind() => lex_token,
-                _ => return None,
-            };
+            let mut new_text = get_text_after_edit(prev_token.clone().into(), &edit);
+            let (new_token_kind, _error) = lex_single_syntax_kind(&new_text)?;
 
-            if lex_token.kind == IDENT && is_contextual_kw(&text) {
+            if new_token_kind != prev_token_kind
+                || (new_token_kind == IDENT && is_contextual_kw(&new_text))
+            {
                 return None;
             }
 
-            if let Some(next_char) = root.text().char_at(token.text_range().end()) {
-                let tokens_with_next_char = tokenize(&format!("{}{}", text, next_char));
-                if tokens_with_next_char.len() == 1 {
+            // Check that edited token is not a part of the bigger token.
+            // E.g. if for source code `bruh"str"` the user removed `ruh`, then
+            // `b` no longer remains an identifier, but becomes a part of byte string literal
+            if let Some(next_char) = root.text().char_at(prev_token.text_range().end()) {
+                new_text.push(next_char);
+                let token_with_next_char = lex_single_syntax_kind(&new_text);
+                if let Some((_kind, _error)) = token_with_next_char {
                     return None;
                 }
+                new_text.pop();
             }
 
-            let new_token = GreenToken::new(rowan::SyntaxKind(token.kind().into()), text.into());
-            Some((token.replace_with(new_token), token.text_range()))
+            let new_token =
+                GreenToken::new(rowan::SyntaxKind(prev_token_kind.into()), new_text.into());
+            Some((prev_token.replace_with(new_token), prev_token.text_range()))
         }
         _ => None,
     }
@@ -83,20 +88,26 @@ fn reparse_block<'node>(
 ) -> Option<(GreenNode, Vec<SyntaxError>, TextRange)> {
     let (node, reparser) = find_reparsable_node(root, edit.delete)?;
     let text = get_text_after_edit(node.clone().into(), &edit);
-    let tokens = tokenize(&text);
+
+    let (tokens, new_lexer_errors) = tokenize(&text);
     if !is_balanced(&tokens) {
         return None;
     }
+
     let mut token_source = TextTokenSource::new(&text, &tokens);
     let mut tree_sink = TextTreeSink::new(&text, &tokens);
     reparser.parse(&mut token_source, &mut tree_sink);
-    let (green, new_errors) = tree_sink.finish();
-    Some((node.replace_with(green), new_errors, node.text_range()))
+
+    let (green, mut new_parser_errors) = tree_sink.finish();
+    new_parser_errors.extend(new_lexer_errors);
+
+    Some((node.replace_with(green), new_parser_errors, node.text_range()))
 }
 
 fn get_text_after_edit(element: SyntaxElement, edit: &AtomTextEdit) -> String {
     let edit =
         AtomTextEdit::replace(edit.delete - element.text_range().start(), edit.insert.clone());
+
     let text = match element {
         NodeOrToken::Token(token) => token.text().to_string(),
         NodeOrToken::Node(node) => node.text().to_string(),
@@ -113,6 +124,7 @@ fn is_contextual_kw(text: &str) -> bool {
 
 fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(SyntaxNode, Reparser)> {
     let node = algo::find_covering_element(node, range);
+
     let mut ancestors = match node {
         NodeOrToken::Token(it) => it.parent().ancestors(),
         NodeOrToken::Node(it) => it.ancestors(),
@@ -182,7 +194,6 @@ mod tests {
         let fully_reparsed = SourceFile::parse(&after);
         let incrementally_reparsed: Parse<SourceFile> = {
             let f = SourceFile::parse(&before);
-            let edit = AtomTextEdit { delete: range, insert: replace_with.to_string() };
             let (green, new_errors, range) =
                 incremental_reparse(f.tree().syntax(), &edit, f.errors.to_vec()).unwrap();
             assert_eq!(range.len(), reparsed_len.into(), "reparsed fragment has wrong length");
diff --git a/crates/ra_syntax/src/parsing/text_tree_sink.rs b/crates/ra_syntax/src/parsing/text_tree_sink.rs
index c36756d6c..dd202601d 100644
--- a/crates/ra_syntax/src/parsing/text_tree_sink.rs
+++ b/crates/ra_syntax/src/parsing/text_tree_sink.rs
@@ -92,8 +92,8 @@ impl<'a> TreeSink for TextTreeSink<'a> {
 }
 
 impl<'a> TextTreeSink<'a> {
-    pub(super) fn new(text: &'a str, tokens: &'a [Token]) -> TextTreeSink<'a> {
-        TextTreeSink {
+    pub(super) fn new(text: &'a str, tokens: &'a [Token]) -> Self {
+        Self {
             text,
             tokens,
             text_pos: 0.into(),
diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs
index 6c171df8d..7f9d36618 100644
--- a/crates/ra_syntax/src/syntax_error.rs
+++ b/crates/ra_syntax/src/syntax_error.rs
@@ -4,7 +4,7 @@ use std::fmt;
 
 use ra_parser::ParseError;
 
-use crate::{validation::EscapeError, TextRange, TextUnit};
+use crate::{validation::EscapeError, TextRange, TextUnit, TokenizeError};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxError {
@@ -12,6 +12,10 @@ pub struct SyntaxError {
     location: Location,
 }
 
+// FIXME: Location should be just `Location(TextRange)`
+// TextUnit enum member just unnecessarily compicates things,
+// we should'n treat it specially, it just as a `TextRange { start: x, end: x + 1 }`
+// see `location_to_range()` in ra_ide/src/diagnostics
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub enum Location {
     Offset(TextUnit),
@@ -67,6 +71,10 @@ impl SyntaxError {
 
         self
     }
+
+    pub fn debug_dump(&self, acc: &mut impl fmt::Write) {
+        writeln!(acc, "error {:?}: {}", self.location(), self.kind()).unwrap();
+    }
 }
 
 impl fmt::Display for SyntaxError {
@@ -79,6 +87,10 @@ impl fmt::Display for SyntaxError {
 pub enum SyntaxErrorKind {
     ParseError(ParseError),
     EscapeError(EscapeError),
+    TokenizeError(TokenizeError),
+    // FIXME: the obvious pattern of this enum dictates that the following enum variants
+    // should be wrapped into something like `SemmanticError(SemmanticError)`
+    // or `ValidateError(ValidateError)` or `SemmanticValidateError(...)`
     InvalidBlockAttr,
     InvalidMatchInnerAttr,
     InvalidTupleIndexFormat,
@@ -101,6 +113,7 @@ impl fmt::Display for SyntaxErrorKind {
             }
             ParseError(msg) => write!(f, "{}", msg.0),
             EscapeError(err) => write!(f, "{}", err),
+            TokenizeError(err) => write!(f, "{}", err),
             VisibilityNotAllowed => {
                 write!(f, "unnecessary visibility qualifier")
             }
@@ -111,6 +124,51 @@ impl fmt::Display for SyntaxErrorKind {
     }
 }
 
+impl fmt::Display for TokenizeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[rustfmt::skip]
+        let msg = match self {
+            TokenizeError::EmptyInt => {
+                "Missing digits after the integer base prefix"
+            }
+            TokenizeError::EmptyExponent => {
+                "Missing digits after the exponent symbol"
+            }
+            TokenizeError::UnterminatedBlockComment => {
+                "Missing trailing `*/` symbols to terminate the block comment"
+            }
+            TokenizeError::UnterminatedChar => {
+                "Missing trailing `'` symbol to terminate the character literal"
+            }
+            TokenizeError::UnterminatedByte => {
+                "Missing trailing `'` symbol to terminate the byte literal"
+            }
+            TokenizeError::UnterminatedString => {
+                "Missing trailing `\"` symbol to terminate the string literal"
+            }
+            TokenizeError::UnterminatedByteString => {
+                "Missing trailing `\"` symbol to terminate the byte string literal"
+            }
+            TokenizeError::UnterminatedRawString => {
+                "Missing trailing `\"` with `#` symbols to terminate the raw string literal"
+            }
+            TokenizeError::UnterminatedRawByteString => {
+                "Missing trailing `\"` with `#` symbols to terminate the raw byte string literal"
+            }
+            TokenizeError::UnstartedRawString => {
+                "Missing `\"` symbol after `#` symbols to begin the raw string literal"
+            }
+            TokenizeError::UnstartedRawByteString => {
+                "Missing `\"` symbol after `#` symbols to begin the raw byte string literal"
+            }
+            TokenizeError::LifetimeStartsWithNumber => {
+                "Lifetime name cannot start with a number"
+            }
+        };
+        write!(f, "{}", msg)
+    }
+}
+
 impl fmt::Display for EscapeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let msg = match self {
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index b3eb5da63..7c2b18af3 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -4,7 +4,7 @@
 //! `SyntaxNode`, and a basic traversal API (parent, children, siblings).
 //!
 //! The *real* implementation is in the (language-agnostic) `rowan` crate, this
-//! modules just wraps its API.
+//! module just wraps its API.
 
 use ra_parser::ParseError;
 use rowan::{GreenNodeBuilder, Language};
@@ -38,17 +38,12 @@ pub type SyntaxElementChildren = rowan::SyntaxElementChildren<RustLanguage>;
 
 pub use rowan::{Direction, NodeOrToken};
 
+#[derive(Default)]
 pub struct SyntaxTreeBuilder {
     errors: Vec<SyntaxError>,
     inner: GreenNodeBuilder<'static>,
 }
 
-impl Default for SyntaxTreeBuilder {
-    fn default() -> SyntaxTreeBuilder {
-        SyntaxTreeBuilder { errors: Vec::new(), inner: GreenNodeBuilder::new() }
-    }
-}
-
 impl SyntaxTreeBuilder {
     pub(crate) fn finish_raw(self) -> (GreenNode, Vec<SyntaxError>) {
         let green = self.inner.finish();
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index 458920607..fb22b9e54 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -1,18 +1,28 @@
 use std::{
     fmt::Write,
-    path::{Component, PathBuf},
+    path::{Component, Path, PathBuf},
 };
 
 use test_utils::{collect_tests, dir_tests, project_dir, read_text};
 
-use crate::{fuzz, SourceFile};
+use crate::{fuzz, tokenize, Location, SourceFile, SyntaxError, TextRange, Token};
 
 #[test]
 fn lexer_tests() {
-    dir_tests(&test_data_dir(), &["lexer"], |text, _| {
-        let tokens = crate::tokenize(text);
-        dump_tokens(&tokens, text)
-    })
+    // FIXME:
+    // * Add tests for unicode escapes in byte-character and [raw]-byte-string literals
+    // * Add tests for unescape errors
+
+    dir_tests(&test_data_dir(), &["lexer/ok"], |text, path| {
+        let (tokens, errors) = tokenize(text);
+        assert_errors_are_absent(&errors, path);
+        dump_tokens_and_errors(&tokens, &errors, text)
+    });
+    dir_tests(&test_data_dir(), &["lexer/err"], |text, path| {
+        let (tokens, errors) = tokenize(text);
+        assert_errors_are_present(&errors, path);
+        dump_tokens_and_errors(&tokens, &errors, text)
+    });
 }
 
 #[test]
@@ -32,18 +42,13 @@ fn parser_tests() {
     dir_tests(&test_data_dir(), &["parser/inline/ok", "parser/ok"], |text, path| {
         let parse = SourceFile::parse(text);
         let errors = parse.errors();
-        assert_eq!(
-            errors,
-            &[] as &[crate::SyntaxError],
-            "There should be no errors in the file {:?}",
-            path.display(),
-        );
+        assert_errors_are_absent(&errors, path);
         parse.debug_dump()
     });
     dir_tests(&test_data_dir(), &["parser/err", "parser/inline/err"], |text, path| {
         let parse = SourceFile::parse(text);
         let errors = parse.errors();
-        assert!(!errors.is_empty(), "There should be errors in the file {:?}", path.display());
+        assert_errors_are_present(&errors, path);
         parse.debug_dump()
     });
 }
@@ -75,7 +80,7 @@ fn self_hosting_parsing() {
         .into_iter()
         .filter_entry(|entry| {
             !entry.path().components().any(|component| {
-                // Get all files which are not in the crates/ra_syntax/tests/data folder
+                // Get all files which are not in the crates/ra_syntax/test_data folder
                 component == Component::Normal(OsStr::new("test_data"))
             })
         })
@@ -101,15 +106,47 @@ fn test_data_dir() -> PathBuf {
     project_dir().join("crates/ra_syntax/test_data")
 }
 
-fn dump_tokens(tokens: &[crate::Token], text: &str) -> String {
+fn assert_errors_are_present(errors: &[SyntaxError], path: &Path) {
+    assert!(!errors.is_empty(), "There should be errors in the file {:?}", path.display());
+}
+fn assert_errors_are_absent(errors: &[SyntaxError], path: &Path) {
+    assert_eq!(
+        errors,
+        &[] as &[SyntaxError],
+        "There should be no errors in the file {:?}",
+        path.display(),
+    );
+}
+
+fn dump_tokens_and_errors(tokens: &[Token], errors: &[SyntaxError], text: &str) -> String {
     let mut acc = String::new();
     let mut offset = 0;
     for token in tokens {
-        let len: u32 = token.len.into();
-        let len = len as usize;
-        let token_text = &text[offset..offset + len];
-        offset += len;
-        write!(acc, "{:?} {} {:?}\n", token.kind, token.len, token_text).unwrap()
+        let token_len = token.len.to_usize();
+        let token_text = &text[offset..offset + token_len];
+        offset += token_len;
+        writeln!(acc, "{:?} {} {:?}", token.kind, token_len, token_text).unwrap();
+    }
+    for err in errors {
+        let err_range = location_to_range(err.location());
+        writeln!(
+            acc,
+            "> error{:?} token({:?}) msg({})",
+            err.location(),
+            &text[err_range],
+            err.kind()
+        )
+        .unwrap();
+    }
+    return acc;
+
+    // FIXME: copy-pasted this from `ra_ide/src/diagnostics.rs`
+    // `Location` will be refactored soon in new PR, see todos here:
+    // https://github.com/rust-analyzer/rust-analyzer/issues/223
+    fn location_to_range(location: Location) -> TextRange {
+        match location {
+            Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
+            Location::Range(range) => range,
+        }
     }
-    acc
 }
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 445e3b3e4..8a5f0e4b7 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -94,6 +94,12 @@ impl From<rustc_lexer::unescape::EscapeError> for SyntaxErrorKind {
 }
 
 pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
+    // FIXME:
+    // * Add validation of character literal containing only a single char
+    // * Add validation of `crate` keyword not appearing in the middle of the symbol path
+    // * Add validation of doc comments are being attached to nodes
+    // * Remove validation of unterminated literals (it is already implemented in `tokenize()`)
+
     let mut errors = Vec::new();
     for node in root.descendants() {
         match_ast! {
diff --git a/crates/ra_syntax/test_data/lexer/0010_comments.rs b/crates/ra_syntax/test_data/lexer/0010_comments.rs
deleted file mode 100644
index 71bdd1f9c..000000000
--- a/crates/ra_syntax/test_data/lexer/0010_comments.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-// hello
-//! World
diff --git a/crates/ra_syntax/test_data/lexer/0010_comments.txt b/crates/ra_syntax/test_data/lexer/0010_comments.txt
deleted file mode 100644
index 3c997de3f..000000000
--- a/crates/ra_syntax/test_data/lexer/0010_comments.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-SHEBANG 19 "#!/usr/bin/env bash"
-WHITESPACE 1 "\n"
-COMMENT 8 "// hello"
-WHITESPACE 1 "\n"
-COMMENT 9 "//! World"
-WHITESPACE 1 "\n"
diff --git a/crates/ra_syntax/test_data/lexer/0014_unclosed_char.rs b/crates/ra_syntax/test_data/lexer/0014_unclosed_char.rs
deleted file mode 100644
index 9c0007077..000000000
--- a/crates/ra_syntax/test_data/lexer/0014_unclosed_char.rs
+++ /dev/null
@@ -1 +0,0 @@
-'1
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/0014_unclosed_char.txt b/crates/ra_syntax/test_data/lexer/0014_unclosed_char.txt
deleted file mode 100644
index 737a300ee..000000000
--- a/crates/ra_syntax/test_data/lexer/0014_unclosed_char.txt
+++ /dev/null
@@ -1 +0,0 @@
-LIFETIME 2 "\'1"
diff --git a/crates/ra_syntax/test_data/lexer/0015_unclosed_string.rs b/crates/ra_syntax/test_data/lexer/0015_unclosed_string.rs
deleted file mode 100644
index d771a26d4..000000000
--- a/crates/ra_syntax/test_data/lexer/0015_unclosed_string.rs
+++ /dev/null
@@ -1 +0,0 @@
-"hello
diff --git a/crates/ra_syntax/test_data/lexer/0015_unclosed_string.txt b/crates/ra_syntax/test_data/lexer/0015_unclosed_string.txt
deleted file mode 100644
index 728c40b66..000000000
--- a/crates/ra_syntax/test_data/lexer/0015_unclosed_string.txt
+++ /dev/null
@@ -1 +0,0 @@
-STRING 7 "\"hello\n"
diff --git a/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.rs
new file mode 100644
index 000000000..ad2823b48
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.rs
@@ -0,0 +1 @@
+'
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.txt
new file mode 100644
index 000000000..f24e1fd32
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0001_unclosed_char_at_eof.txt
@@ -0,0 +1,2 @@
+CHAR 1 "\'"
+> error[0; 1) token("\'") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.rs
new file mode 100644
index 000000000..e264a4152
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.rs
@@ -0,0 +1 @@
+'🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.txt
new file mode 100644
index 000000000..bd08cfc44
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0002_unclosed_char_with_ferris.txt
@@ -0,0 +1,2 @@
+CHAR 5 "\'🦀"
+> error[0; 5) token("\'🦀") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.rs
new file mode 100644
index 000000000..cf74b4dad
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.rs
@@ -0,0 +1 @@
+'\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.txt
new file mode 100644
index 000000000..0ee22912d
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0003_unclosed_char_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+CHAR 5 "\'\\x7f"
+> error[0; 5) token("\'\\x7f") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.rs
new file mode 100644
index 000000000..50be91f68
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.rs
@@ -0,0 +1 @@
+'\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.txt
new file mode 100644
index 000000000..96fac42ce
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0004_unclosed_char_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+CHAR 9 "\'\\u{20AA}"
+> error[0; 9) token("\'\\u{20AA}") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.rs
new file mode 100644
index 000000000..309ecfe47
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.rs
@@ -0,0 +1 @@
+' 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.txt
new file mode 100644
index 000000000..2059f3f81
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0005_unclosed_char_with_space.txt
@@ -0,0 +1,2 @@
+CHAR 2 "\' "
+> error[0; 2) token("\' ") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.rs
new file mode 100644
index 000000000..6ba258b10
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.rs
@@ -0,0 +1 @@
+'\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.txt
new file mode 100644
index 000000000..7dd376e59
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0006_unclosed_char_with_slash.txt
@@ -0,0 +1,2 @@
+CHAR 2 "\'\\"
+> error[0; 2) token("\'\\") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.rs
new file mode 100644
index 000000000..78bef7e3e
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.rs
@@ -0,0 +1 @@
+'\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.txt
new file mode 100644
index 000000000..ef7a0a147
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0007_unclosed_char_with_slash_n.txt
@@ -0,0 +1,2 @@
+CHAR 3 "\'\\n"
+> error[0; 3) token("\'\\n") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.rs b/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.rs
new file mode 100644
index 000000000..a0e722065
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.rs
@@ -0,0 +1 @@
+'\'
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.txt b/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.txt
new file mode 100644
index 000000000..13fc5ea9a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0008_unclosed_char_with_slash_single_quote.txt
@@ -0,0 +1,2 @@
+CHAR 3 "\'\\\'"
+> error[0; 3) token("\'\\\'") msg(Missing trailing `'` symbol to terminate the character literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.rs
new file mode 100644
index 000000000..795dc7e25
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.rs
@@ -0,0 +1 @@
+b'
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.txt
new file mode 100644
index 000000000..269d68c74
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0009_unclosed_byte_at_eof.txt
@@ -0,0 +1,2 @@
+BYTE 2 "b\'"
+> error[0; 2) token("b\'") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.rs
new file mode 100644
index 000000000..c9230dc24
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.rs
@@ -0,0 +1 @@
+b'🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.txt
new file mode 100644
index 000000000..91a76e479
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0010_unclosed_byte_with_ferris.txt
@@ -0,0 +1,2 @@
+BYTE 6 "b\'🦀"
+> error[0; 6) token("b\'🦀") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.rs
new file mode 100644
index 000000000..d146a8090
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.rs
@@ -0,0 +1 @@
+b'\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.txt
new file mode 100644
index 000000000..b8c804a18
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0011_unclosed_byte_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+BYTE 6 "b\'\\x7f"
+> error[0; 6) token("b\'\\x7f") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.rs
new file mode 100644
index 000000000..a3dec7c25
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.rs
@@ -0,0 +1 @@
+b'\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.txt
new file mode 100644
index 000000000..dfca22a59
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0012_unclosed_byte_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+BYTE 10 "b\'\\u{20AA}"
+> error[0; 10) token("b\'\\u{20AA}") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.rs
new file mode 100644
index 000000000..93b7f9c87
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.rs
@@ -0,0 +1 @@
+b' 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.txt
new file mode 100644
index 000000000..51a1cceab
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0013_unclosed_byte_with_space.txt
@@ -0,0 +1,2 @@
+BYTE 3 "b\' "
+> error[0; 3) token("b\' ") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.rs
new file mode 100644
index 000000000..abffa5037
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.rs
@@ -0,0 +1 @@
+b'\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.txt
new file mode 100644
index 000000000..24e835c27
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0014_unclosed_byte_with_slash.txt
@@ -0,0 +1,2 @@
+BYTE 3 "b\'\\"
+> error[0; 3) token("b\'\\") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.rs
new file mode 100644
index 000000000..4f46836a9
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.rs
@@ -0,0 +1 @@
+b'\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.txt
new file mode 100644
index 000000000..f1e39a41b
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0015_unclosed_byte_with_slash_n.txt
@@ -0,0 +1,2 @@
+BYTE 4 "b\'\\n"
+> error[0; 4) token("b\'\\n") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.rs b/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.rs
new file mode 100644
index 000000000..645b641ee
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.rs
@@ -0,0 +1 @@
+b'\'
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.txt b/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.txt
new file mode 100644
index 000000000..f8ffe815d
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0016_unclosed_byte_with_slash_single_quote.txt
@@ -0,0 +1,2 @@
+BYTE 4 "b\'\\\'"
+> error[0; 4) token("b\'\\\'") msg(Missing trailing `'` symbol to terminate the byte literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.rs
new file mode 100644
index 000000000..9d68933c4
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.rs
@@ -0,0 +1 @@
+"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.txt
new file mode 100644
index 000000000..823daaf6f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0017_unclosed_string_at_eof.txt
@@ -0,0 +1,2 @@
+STRING 1 "\""
+> error[0; 1) token("\"") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.rs
new file mode 100644
index 000000000..d439b8d2a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.rs
@@ -0,0 +1 @@
+"🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.txt
new file mode 100644
index 000000000..164580eb3
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0018_unclosed_string_with_ferris.txt
@@ -0,0 +1,2 @@
+STRING 5 "\"🦀"
+> error[0; 5) token("\"🦀") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.rs
new file mode 100644
index 000000000..56186a344
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.rs
@@ -0,0 +1 @@
+"\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.txt
new file mode 100644
index 000000000..4453827c3
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0019_unclosed_string_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+STRING 5 "\"\\x7f"
+> error[0; 5) token("\"\\x7f") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.rs
new file mode 100644
index 000000000..ed24095c3
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.rs
@@ -0,0 +1 @@
+"\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.txt
new file mode 100644
index 000000000..aa614f304
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0020_unclosed_string_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+STRING 9 "\"\\u{20AA}"
+> error[0; 9) token("\"\\u{20AA}") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.rs
new file mode 100644
index 000000000..72cdc841f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.rs
@@ -0,0 +1 @@
+" 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.txt
new file mode 100644
index 000000000..b7db1236f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0021_unclosed_string_with_space.txt
@@ -0,0 +1,2 @@
+STRING 2 "\" "
+> error[0; 2) token("\" ") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.rs
new file mode 100644
index 000000000..00a258400
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.rs
@@ -0,0 +1 @@
+"\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.txt
new file mode 100644
index 000000000..9d3df3799
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0022_unclosed_string_with_slash.txt
@@ -0,0 +1,2 @@
+STRING 2 "\"\\"
+> error[0; 2) token("\"\\") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.rs
new file mode 100644
index 000000000..a0c29b8cf
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.rs
@@ -0,0 +1 @@
+"\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.txt
new file mode 100644
index 000000000..e3eb672b6
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0023_unclosed_string_with_slash_n.txt
@@ -0,0 +1,2 @@
+STRING 3 "\"\\n"
+> error[0; 3) token("\"\\n") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.rs b/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.rs
new file mode 100644
index 000000000..403c2d6dd
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.rs
@@ -0,0 +1 @@
+"\"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.txt b/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.txt
new file mode 100644
index 000000000..041d7fb6e
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0024_unclosed_string_with_slash_double_quote.txt
@@ -0,0 +1,2 @@
+STRING 3 "\"\\\""
+> error[0; 3) token("\"\\\"") msg(Missing trailing `"` symbol to terminate the string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.rs
new file mode 100644
index 000000000..36f4f4321
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.rs
@@ -0,0 +1 @@
+b"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.txt
new file mode 100644
index 000000000..be7970a83
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0025_unclosed_byte_string_at_eof.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 2 "b\""
+> error[0; 2) token("b\"") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.rs
new file mode 100644
index 000000000..3c23a0372
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.rs
@@ -0,0 +1 @@
+b"🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.txt
new file mode 100644
index 000000000..bf9aab132
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0026_unclosed_byte_string_with_ferris.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 6 "b\"🦀"
+> error[0; 6) token("b\"🦀") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.rs
new file mode 100644
index 000000000..836c112c1
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.rs
@@ -0,0 +1 @@
+b"\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.txt
new file mode 100644
index 000000000..76e16d7d3
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0027_unclosed_byte_string_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 6 "b\"\\x7f"
+> error[0; 6) token("b\"\\x7f") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.rs
new file mode 100644
index 000000000..1c6df1d00
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.rs
@@ -0,0 +1 @@
+b"\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.txt
new file mode 100644
index 000000000..09adffa16
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0028_unclosed_byte_string_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 10 "b\"\\u{20AA}"
+> error[0; 10) token("b\"\\u{20AA}") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.rs
new file mode 100644
index 000000000..d6898541e
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.rs
@@ -0,0 +1 @@
+b" 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.txt
new file mode 100644
index 000000000..fcb7253c8
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0029_unclosed_byte_string_with_space.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 3 "b\" "
+> error[0; 3) token("b\" ") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.rs
new file mode 100644
index 000000000..cce661538
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.rs
@@ -0,0 +1 @@
+b"\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.txt
new file mode 100644
index 000000000..0a1b3e269
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0030_unclosed_byte_string_with_slash.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 3 "b\"\\"
+> error[0; 3) token("b\"\\") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.rs
new file mode 100644
index 000000000..5e680aabb
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.rs
@@ -0,0 +1 @@
+b"\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.txt
new file mode 100644
index 000000000..1fb89d2b6
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0031_unclosed_byte_string_with_slash_n.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 4 "b\"\\n"
+> error[0; 4) token("b\"\\n") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.rs b/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.rs
new file mode 100644
index 000000000..f2ff58ba9
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.rs
@@ -0,0 +1 @@
+b"\"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.txt b/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.txt
new file mode 100644
index 000000000..718d36992
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0032_unclosed_byte_string_with_slash_double_quote.txt
@@ -0,0 +1,2 @@
+BYTE_STRING 4 "b\"\\\""
+> error[0; 4) token("b\"\\\"") msg(Missing trailing `"` symbol to terminate the byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.rs
new file mode 100644
index 000000000..557c59b62
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.rs
@@ -0,0 +1 @@
+r##"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt
new file mode 100644
index 000000000..93348f548
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt
@@ -0,0 +1,2 @@
+RAW_STRING 4 "r##\""
+> error[0; 4) token("r##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.rs
new file mode 100644
index 000000000..bd046e4bb
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.rs
@@ -0,0 +1 @@
+r##"🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt
new file mode 100644
index 000000000..42c70dfe8
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt
@@ -0,0 +1,2 @@
+RAW_STRING 8 "r##\"🦀"
+> error[0; 8) token("r##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.rs
new file mode 100644
index 000000000..5bec883dc
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.rs
@@ -0,0 +1 @@
+r##"\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt
new file mode 100644
index 000000000..2bdeea0ff
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+RAW_STRING 8 "r##\"\\x7f"
+> error[0; 8) token("r##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.rs
new file mode 100644
index 000000000..bf05c3913
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.rs
@@ -0,0 +1 @@
+r##"\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt
new file mode 100644
index 000000000..667d4d79f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+RAW_STRING 12 "r##\"\\u{20AA}"
+> error[0; 12) token("r##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.rs
new file mode 100644
index 000000000..f104bae4f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.rs
@@ -0,0 +1 @@
+r##" 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt
new file mode 100644
index 000000000..dd9597a1a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt
@@ -0,0 +1,2 @@
+RAW_STRING 5 "r##\" "
+> error[0; 5) token("r##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.rs
new file mode 100644
index 000000000..9242077b8
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.rs
@@ -0,0 +1 @@
+r##"\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt
new file mode 100644
index 000000000..6ac6e3d62
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt
@@ -0,0 +1,2 @@
+RAW_STRING 5 "r##\"\\"
+> error[0; 5) token("r##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.rs
new file mode 100644
index 000000000..db1c16f2b
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.rs
@@ -0,0 +1 @@
+r##"\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt
new file mode 100644
index 000000000..9d35443f5
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt
@@ -0,0 +1,2 @@
+RAW_STRING 6 "r##\"\\n"
+> error[0; 6) token("r##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.rs
new file mode 100644
index 000000000..ae5bae622
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.rs
@@ -0,0 +1 @@
+br##"
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt
new file mode 100644
index 000000000..81fa39ea5
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 5 "br##\""
+> error[0; 5) token("br##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.rs b/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.rs
new file mode 100644
index 000000000..9ef01207a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.rs
@@ -0,0 +1 @@
+br##"🦀
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt b/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt
new file mode 100644
index 000000000..c2503a4d0
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 9 "br##\"🦀"
+> error[0; 9) token("br##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.rs b/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.rs
new file mode 100644
index 000000000..d50270afe
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.rs
@@ -0,0 +1 @@
+br##"\x7f
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt b/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt
new file mode 100644
index 000000000..3bd3d8152
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 9 "br##\"\\x7f"
+> error[0; 9) token("br##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.rs b/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.rs
new file mode 100644
index 000000000..90e299a1a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.rs
@@ -0,0 +1 @@
+br##"\u{20AA}
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt b/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt
new file mode 100644
index 000000000..a512f0428
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 13 "br##\"\\u{20AA}"
+> error[0; 13) token("br##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.rs b/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.rs
new file mode 100644
index 000000000..14c602fd2
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.rs
@@ -0,0 +1 @@
+br##" 
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt b/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt
new file mode 100644
index 000000000..dc616a623
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 6 "br##\" "
+> error[0; 6) token("br##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.rs b/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.rs
new file mode 100644
index 000000000..0b3c015d7
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.rs
@@ -0,0 +1 @@
+br##"\
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt b/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt
new file mode 100644
index 000000000..debafe380
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 6 "br##\"\\"
+> error[0; 6) token("br##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.rs b/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.rs
new file mode 100644
index 000000000..0d8b0e7ab
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.rs
@@ -0,0 +1 @@
+br##"\n
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt b/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt
new file mode 100644
index 000000000..524e617b7
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 7 "br##\"\\n"
+> error[0; 7) token("br##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.rs
new file mode 100644
index 000000000..eddf8d080
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.rs
@@ -0,0 +1 @@
+r##
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt
new file mode 100644
index 000000000..00b046840
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt
@@ -0,0 +1,2 @@
+RAW_STRING 3 "r##"
+> error[0; 3) token("r##") msg(Missing `"` symbol after `#` symbols to begin the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.rs
new file mode 100644
index 000000000..7e8cadf4f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.rs
@@ -0,0 +1 @@
+br##
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt
new file mode 100644
index 000000000..33b25e60f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt
@@ -0,0 +1,2 @@
+RAW_BYTE_STRING 4 "br##"
+> error[0; 4) token("br##") msg(Missing `"` symbol after `#` symbols to begin the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.rs b/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.rs
new file mode 100644
index 000000000..534668a9b
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.rs
@@ -0,0 +1 @@
+r## I lack a quote!
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt b/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt
new file mode 100644
index 000000000..782dfd974
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt
@@ -0,0 +1,10 @@
+RAW_STRING 4 "r## "
+IDENT 1 "I"
+WHITESPACE 1 " "
+IDENT 4 "lack"
+WHITESPACE 1 " "
+IDENT 1 "a"
+WHITESPACE 1 " "
+IDENT 5 "quote"
+EXCL 1 "!"
+> error[0; 4) token("r## ") msg(Missing `"` symbol after `#` symbols to begin the raw string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.rs b/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.rs
new file mode 100644
index 000000000..d9b55455a
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.rs
@@ -0,0 +1 @@
+br## I lack a quote!
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt b/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt
new file mode 100644
index 000000000..59c40cd65
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt
@@ -0,0 +1,10 @@
+RAW_BYTE_STRING 5 "br## "
+IDENT 1 "I"
+WHITESPACE 1 " "
+IDENT 4 "lack"
+WHITESPACE 1 " "
+IDENT 1 "a"
+WHITESPACE 1 " "
+IDENT 5 "quote"
+EXCL 1 "!"
+> error[0; 5) token("br## ") msg(Missing `"` symbol after `#` symbols to begin the raw byte string literal)
diff --git a/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.rs b/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.rs
new file mode 100644
index 000000000..22e83649f
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.rs
@@ -0,0 +1 @@
+/*
\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.txt b/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.txt
new file mode 100644
index 000000000..5d04cdaa4
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0051_unclosed_block_comment_at_eof.txt
@@ -0,0 +1,2 @@
+COMMENT 2 "/*"
+> error[0; 2) token("/*") msg(Missing trailing `*/` symbols to terminate the block comment)
diff --git a/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.rs b/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.rs
new file mode 100644
index 000000000..c45c2844d
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.rs
@@ -0,0 +1 @@
+/* comment
diff --git a/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.txt b/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.txt
new file mode 100644
index 000000000..8c6b678e3
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0052_unclosed_block_comment_with_content.txt
@@ -0,0 +1,2 @@
+COMMENT 11 "/* comment\n"
+> error[0; 11) token("/* comment\n") msg(Missing trailing `*/` symbols to terminate the block comment)
diff --git a/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.rs b/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.rs
new file mode 100644
index 000000000..3fcfc9660
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.rs
@@ -0,0 +1 @@
+/* /* /*
diff --git a/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.txt b/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.txt
new file mode 100644
index 000000000..250de34d9
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0053_unclosed_nested_block_comment_entirely.txt
@@ -0,0 +1,2 @@
+COMMENT 9 "/* /* /*\n"
+> error[0; 9) token("/* /* /*\n") msg(Missing trailing `*/` symbols to terminate the block comment)
diff --git a/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.rs b/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.rs
new file mode 100644
index 000000000..26c898f01
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.rs
@@ -0,0 +1 @@
+/** /*! /* comment */ */
diff --git a/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.txt b/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.txt
new file mode 100644
index 000000000..f97f2a8c7
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0054_unclosed_nested_block_comment_partially.txt
@@ -0,0 +1,2 @@
+COMMENT 25 "/** /*! /* comment */ */\n"
+> error[0; 25) token("/** /*! /* comment */ */\n") msg(Missing trailing `*/` symbols to terminate the block comment)
diff --git a/crates/ra_syntax/test_data/lexer/err/0055_empty_int.rs b/crates/ra_syntax/test_data/lexer/err/0055_empty_int.rs
new file mode 100644
index 000000000..aa2a9fdca
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0055_empty_int.rs
@@ -0,0 +1,17 @@
+0b
+0o
+0x
+
+0b_
+0o_
+0x_
+
+0bnoDigit
+0onoDigit
+0xnoDigit
+
+0xG
+0xg
+
+0x_g
+0x_G
diff --git a/crates/ra_syntax/test_data/lexer/err/0055_empty_int.txt b/crates/ra_syntax/test_data/lexer/err/0055_empty_int.txt
new file mode 100644
index 000000000..2fe5bd950
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0055_empty_int.txt
@@ -0,0 +1,39 @@
+INT_NUMBER 2 "0b"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "0o"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "0x"
+WHITESPACE 2 "\n\n"
+INT_NUMBER 3 "0b_"
+WHITESPACE 1 "\n"
+INT_NUMBER 3 "0o_"
+WHITESPACE 1 "\n"
+INT_NUMBER 3 "0x_"
+WHITESPACE 2 "\n\n"
+INT_NUMBER 9 "0bnoDigit"
+WHITESPACE 1 "\n"
+INT_NUMBER 9 "0onoDigit"
+WHITESPACE 1 "\n"
+INT_NUMBER 9 "0xnoDigit"
+WHITESPACE 2 "\n\n"
+INT_NUMBER 3 "0xG"
+WHITESPACE 1 "\n"
+INT_NUMBER 3 "0xg"
+WHITESPACE 2 "\n\n"
+INT_NUMBER 4 "0x_g"
+WHITESPACE 1 "\n"
+INT_NUMBER 4 "0x_G"
+WHITESPACE 1 "\n"
+> error[0; 2) token("0b") msg(Missing digits after the integer base prefix)
+> error[3; 5) token("0o") msg(Missing digits after the integer base prefix)
+> error[6; 8) token("0x") msg(Missing digits after the integer base prefix)
+> error[10; 13) token("0b_") msg(Missing digits after the integer base prefix)
+> error[14; 17) token("0o_") msg(Missing digits after the integer base prefix)
+> error[18; 21) token("0x_") msg(Missing digits after the integer base prefix)
+> error[23; 32) token("0bnoDigit") msg(Missing digits after the integer base prefix)
+> error[33; 42) token("0onoDigit") msg(Missing digits after the integer base prefix)
+> error[43; 52) token("0xnoDigit") msg(Missing digits after the integer base prefix)
+> error[54; 57) token("0xG") msg(Missing digits after the integer base prefix)
+> error[58; 61) token("0xg") msg(Missing digits after the integer base prefix)
+> error[63; 67) token("0x_g") msg(Missing digits after the integer base prefix)
+> error[68; 72) token("0x_G") msg(Missing digits after the integer base prefix)
diff --git a/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.rs b/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.rs
new file mode 100644
index 000000000..286584c88
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.rs
@@ -0,0 +1,22 @@
+0e
+0E
+
+42e+
+42e-
+42E+
+42E-
+
+42.e+
+42.e-
+42.E+
+42.E-
+
+42.2e+
+42.2e-
+42.2E+
+42.2E-
+
+42.2e+f32
+42.2e-f32
+42.2E+f32
+42.2E-f32
diff --git a/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.txt b/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.txt
new file mode 100644
index 000000000..ab35e20a5
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0056_empty_exponent.txt
@@ -0,0 +1,62 @@
+FLOAT_NUMBER 2 "0e"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 2 "0E"
+WHITESPACE 2 "\n\n"
+FLOAT_NUMBER 4 "42e+"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 4 "42e-"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 4 "42E+"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 4 "42E-"
+WHITESPACE 2 "\n\n"
+INT_NUMBER 2 "42"
+DOT 1 "."
+IDENT 1 "e"
+PLUS 1 "+"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "42"
+DOT 1 "."
+IDENT 1 "e"
+MINUS 1 "-"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "42"
+DOT 1 "."
+IDENT 1 "E"
+PLUS 1 "+"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "42"
+DOT 1 "."
+IDENT 1 "E"
+MINUS 1 "-"
+WHITESPACE 2 "\n\n"
+FLOAT_NUMBER 6 "42.2e+"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 6 "42.2e-"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 6 "42.2E+"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 6 "42.2E-"
+WHITESPACE 2 "\n\n"
+FLOAT_NUMBER 9 "42.2e+f32"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 9 "42.2e-f32"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 9 "42.2E+f32"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 9 "42.2E-f32"
+WHITESPACE 1 "\n"
+> error[0; 2) token("0e") msg(Missing digits after the exponent symbol)
+> error[3; 5) token("0E") msg(Missing digits after the exponent symbol)
+> error[7; 11) token("42e+") msg(Missing digits after the exponent symbol)
+> error[12; 16) token("42e-") msg(Missing digits after the exponent symbol)
+> error[17; 21) token("42E+") msg(Missing digits after the exponent symbol)
+> error[22; 26) token("42E-") msg(Missing digits after the exponent symbol)
+> error[53; 59) token("42.2e+") msg(Missing digits after the exponent symbol)
+> error[60; 66) token("42.2e-") msg(Missing digits after the exponent symbol)
+> error[67; 73) token("42.2E+") msg(Missing digits after the exponent symbol)
+> error[74; 80) token("42.2E-") msg(Missing digits after the exponent symbol)
+> error[82; 91) token("42.2e+f32") msg(Missing digits after the exponent symbol)
+> error[92; 101) token("42.2e-f32") msg(Missing digits after the exponent symbol)
+> error[102; 111) token("42.2E+f32") msg(Missing digits after the exponent symbol)
+> error[112; 121) token("42.2E-f32") msg(Missing digits after the exponent symbol)
diff --git a/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.rs b/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.rs
new file mode 100644
index 000000000..a7698a404
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.rs
@@ -0,0 +1,2 @@
+'1
+'1lifetime
diff --git a/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.txt b/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.txt
new file mode 100644
index 000000000..89b38bfac
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/err/0057_lifetime_strarts_with_a_number.txt
@@ -0,0 +1,6 @@
+LIFETIME 2 "\'1"
+WHITESPACE 1 "\n"
+LIFETIME 10 "\'1lifetime"
+WHITESPACE 1 "\n"
+> error[0; 2) token("\'1") msg(Lifetime name cannot start with a number)
+> error[3; 13) token("\'1lifetime") msg(Lifetime name cannot start with a number)
diff --git a/crates/ra_syntax/test_data/lexer/0001_hello.rs b/crates/ra_syntax/test_data/lexer/ok/0001_hello.rs
index 95d09f2b1..95d09f2b1 100644
--- a/crates/ra_syntax/test_data/lexer/0001_hello.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0001_hello.rs
diff --git a/crates/ra_syntax/test_data/lexer/0001_hello.txt b/crates/ra_syntax/test_data/lexer/ok/0001_hello.txt
index 27a5940a9..27a5940a9 100644
--- a/crates/ra_syntax/test_data/lexer/0001_hello.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0001_hello.txt
diff --git a/crates/ra_syntax/test_data/lexer/0002_whitespace.rs b/crates/ra_syntax/test_data/lexer/ok/0002_whitespace.rs
index 08fce1418..08fce1418 100644
--- a/crates/ra_syntax/test_data/lexer/0002_whitespace.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0002_whitespace.rs
diff --git a/crates/ra_syntax/test_data/lexer/0002_whitespace.txt b/crates/ra_syntax/test_data/lexer/ok/0002_whitespace.txt
index 01d260918..01d260918 100644
--- a/crates/ra_syntax/test_data/lexer/0002_whitespace.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0002_whitespace.txt
diff --git a/crates/ra_syntax/test_data/lexer/0003_ident.rs b/crates/ra_syntax/test_data/lexer/ok/0003_ident.rs
index c05c9c009..c05c9c009 100644
--- a/crates/ra_syntax/test_data/lexer/0003_ident.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0003_ident.rs
diff --git a/crates/ra_syntax/test_data/lexer/0003_ident.txt b/crates/ra_syntax/test_data/lexer/ok/0003_ident.txt
index 4a0d5c053..4a0d5c053 100644
--- a/crates/ra_syntax/test_data/lexer/0003_ident.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0003_ident.txt
diff --git a/crates/ra_syntax/test_data/lexer/0004_numbers.rs b/crates/ra_syntax/test_data/lexer/ok/0004_numbers.rs
index dc974b553..bc761c235 100644
--- a/crates/ra_syntax/test_data/lexer/0004_numbers.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0004_numbers.rs
@@ -1,4 +1,4 @@
-0 0b 0o 0x 00 0_ 0. 0e 0E 0z
+0 00 0_ 0. 0z
 01790 0b1790 0o1790 0x1790aAbBcCdDeEfF 001279 0_1279 0.1279 0e1279 0E1279
 0..2
 0.foo()
@@ -6,4 +6,4 @@
 0.e+1
 0.0E-2
 0___0.10000____0000e+111__
-1i64 92.0f32 11__s
\ No newline at end of file
+1i64 92.0f32 11__s
diff --git a/crates/ra_syntax/test_data/lexer/0004_numbers.txt b/crates/ra_syntax/test_data/lexer/ok/0004_numbers.txt
index 7bb89b8ae..e19fc5789 100644
--- a/crates/ra_syntax/test_data/lexer/0004_numbers.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0004_numbers.txt
@@ -1,21 +1,11 @@
 INT_NUMBER 1 "0"
 WHITESPACE 1 " "
-INT_NUMBER 2 "0b"
-WHITESPACE 1 " "
-INT_NUMBER 2 "0o"
-WHITESPACE 1 " "
-INT_NUMBER 2 "0x"
-WHITESPACE 1 " "
 INT_NUMBER 2 "00"
 WHITESPACE 1 " "
 INT_NUMBER 2 "0_"
 WHITESPACE 1 " "
 FLOAT_NUMBER 2 "0."
 WHITESPACE 1 " "
-FLOAT_NUMBER 2 "0e"
-WHITESPACE 1 " "
-FLOAT_NUMBER 2 "0E"
-WHITESPACE 1 " "
 INT_NUMBER 2 "0z"
 WHITESPACE 1 "\n"
 INT_NUMBER 5 "01790"
@@ -64,3 +54,4 @@ WHITESPACE 1 " "
 FLOAT_NUMBER 7 "92.0f32"
 WHITESPACE 1 " "
 INT_NUMBER 5 "11__s"
+WHITESPACE 1 "\n"
diff --git a/crates/ra_syntax/test_data/lexer/0005_symbols.rs b/crates/ra_syntax/test_data/lexer/ok/0005_symbols.rs
index 487569b5a..487569b5a 100644
--- a/crates/ra_syntax/test_data/lexer/0005_symbols.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0005_symbols.rs
diff --git a/crates/ra_syntax/test_data/lexer/0005_symbols.txt b/crates/ra_syntax/test_data/lexer/ok/0005_symbols.txt
index 469a90e42..469a90e42 100644
--- a/crates/ra_syntax/test_data/lexer/0005_symbols.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0005_symbols.txt
diff --git a/crates/ra_syntax/test_data/lexer/0006_chars.rs b/crates/ra_syntax/test_data/lexer/ok/0006_chars.rs
index 454ee0a5f..454ee0a5f 100644
--- a/crates/ra_syntax/test_data/lexer/0006_chars.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0006_chars.rs
diff --git a/crates/ra_syntax/test_data/lexer/0006_chars.txt b/crates/ra_syntax/test_data/lexer/ok/0006_chars.txt
index 950954fbc..950954fbc 100644
--- a/crates/ra_syntax/test_data/lexer/0006_chars.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0006_chars.txt
diff --git a/crates/ra_syntax/test_data/lexer/0007_lifetimes.rs b/crates/ra_syntax/test_data/lexer/ok/0007_lifetimes.rs
index b764f1dce..b764f1dce 100644
--- a/crates/ra_syntax/test_data/lexer/0007_lifetimes.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0007_lifetimes.rs
diff --git a/crates/ra_syntax/test_data/lexer/0007_lifetimes.txt b/crates/ra_syntax/test_data/lexer/ok/0007_lifetimes.txt
index 005c29100..005c29100 100644
--- a/crates/ra_syntax/test_data/lexer/0007_lifetimes.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0007_lifetimes.txt
diff --git a/crates/ra_syntax/test_data/lexer/0008_byte_strings.rs b/crates/ra_syntax/test_data/lexer/ok/0008_byte_strings.rs
index b54930f5e..b54930f5e 100644
--- a/crates/ra_syntax/test_data/lexer/0008_byte_strings.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0008_byte_strings.rs
diff --git a/crates/ra_syntax/test_data/lexer/0008_byte_strings.txt b/crates/ra_syntax/test_data/lexer/ok/0008_byte_strings.txt
index bc03b51a8..bc03b51a8 100644
--- a/crates/ra_syntax/test_data/lexer/0008_byte_strings.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0008_byte_strings.txt
diff --git a/crates/ra_syntax/test_data/lexer/0009_strings.rs b/crates/ra_syntax/test_data/lexer/ok/0009_strings.rs
index 4ddb5bffc..4ddb5bffc 100644
--- a/crates/ra_syntax/test_data/lexer/0009_strings.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0009_strings.rs
diff --git a/crates/ra_syntax/test_data/lexer/0009_strings.txt b/crates/ra_syntax/test_data/lexer/ok/0009_strings.txt
index 4cb4d711d..4cb4d711d 100644
--- a/crates/ra_syntax/test_data/lexer/0009_strings.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0009_strings.txt
diff --git a/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.rs b/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.rs
new file mode 100644
index 000000000..4b6653f9c
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.rs
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+// hello
+//! World
+//!! Inner line doc
+/// Outer line doc
+//// Just a comment
+
+//
+//!
+//!!
+///
+////
diff --git a/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.txt b/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.txt
new file mode 100644
index 000000000..98a3818c0
--- /dev/null
+++ b/crates/ra_syntax/test_data/lexer/ok/0010_single_line_comments.txt
@@ -0,0 +1,22 @@
+SHEBANG 19 "#!/usr/bin/env bash"
+WHITESPACE 1 "\n"
+COMMENT 8 "// hello"
+WHITESPACE 1 "\n"
+COMMENT 9 "//! World"
+WHITESPACE 1 "\n"
+COMMENT 19 "//!! Inner line doc"
+WHITESPACE 1 "\n"
+COMMENT 18 "/// Outer line doc"
+WHITESPACE 1 "\n"
+COMMENT 19 "//// Just a comment"
+WHITESPACE 2 "\n\n"
+COMMENT 2 "//"
+WHITESPACE 1 "\n"
+COMMENT 3 "//!"
+WHITESPACE 1 "\n"
+COMMENT 4 "//!!"
+WHITESPACE 1 "\n"
+COMMENT 3 "///"
+WHITESPACE 1 "\n"
+COMMENT 4 "////"
+WHITESPACE 1 "\n"
diff --git a/crates/ra_syntax/test_data/lexer/0011_keywords.rs b/crates/ra_syntax/test_data/lexer/ok/0011_keywords.rs
index 1e91bff4e..1e91bff4e 100644
--- a/crates/ra_syntax/test_data/lexer/0011_keywords.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0011_keywords.rs
diff --git a/crates/ra_syntax/test_data/lexer/0011_keywords.txt b/crates/ra_syntax/test_data/lexer/ok/0011_keywords.txt
index 22c00eefb..22c00eefb 100644
--- a/crates/ra_syntax/test_data/lexer/0011_keywords.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0011_keywords.txt
diff --git a/crates/ra_syntax/test_data/lexer/00012_block_comment.rs b/crates/ra_syntax/test_data/lexer/ok/0012_block_comment.rs
index 708aac197..b880a59d9 100644
--- a/crates/ra_syntax/test_data/lexer/00012_block_comment.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0012_block_comment.rs
@@ -1,4 +1,3 @@
 /* */
 /**/
 /* /* */ */
-/*
diff --git a/crates/ra_syntax/test_data/lexer/00012_block_comment.txt b/crates/ra_syntax/test_data/lexer/ok/0012_block_comment.txt
index 9958b2518..2618e287e 100644
--- a/crates/ra_syntax/test_data/lexer/00012_block_comment.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0012_block_comment.txt
@@ -4,4 +4,3 @@ COMMENT 4 "/**/"
 WHITESPACE 1 "\n"
 COMMENT 11 "/* /* */ */"
 WHITESPACE 1 "\n"
-COMMENT 3 "/*\n"
diff --git a/crates/ra_syntax/test_data/lexer/0013_raw_strings.rs b/crates/ra_syntax/test_data/lexer/ok/0013_raw_strings.rs
index e5ed0b693..e5ed0b693 100644
--- a/crates/ra_syntax/test_data/lexer/0013_raw_strings.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0013_raw_strings.rs
diff --git a/crates/ra_syntax/test_data/lexer/0013_raw_strings.txt b/crates/ra_syntax/test_data/lexer/ok/0013_raw_strings.txt
index 9cf0957d1..9cf0957d1 100644
--- a/crates/ra_syntax/test_data/lexer/0013_raw_strings.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0013_raw_strings.txt
diff --git a/crates/ra_syntax/test_data/lexer/0016_raw_ident.rs b/crates/ra_syntax/test_data/lexer/ok/0014_raw_ident.rs
index b40a1b6a2..b40a1b6a2 100644
--- a/crates/ra_syntax/test_data/lexer/0016_raw_ident.rs
+++ b/crates/ra_syntax/test_data/lexer/ok/0014_raw_ident.rs
diff --git a/crates/ra_syntax/test_data/lexer/0016_raw_ident.txt b/crates/ra_syntax/test_data/lexer/ok/0014_raw_ident.txt
index 484689693..484689693 100644
--- a/crates/ra_syntax/test_data/lexer/0016_raw_ident.txt
+++ b/crates/ra_syntax/test_data/lexer/ok/0014_raw_ident.txt
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.rs b/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.rs
index 16edee95d..731e58013 100644
--- a/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.rs
+++ b/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.rs
@@ -1,2 +1,2 @@
-async unsafe fn foo() {}
+unsafe async fn foo() {}
 unsafe const fn bar() {}
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.txt b/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.txt
index 2ea6a566d..289193b9e 100644
--- a/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.txt
+++ b/crates/ra_syntax/test_data/parser/inline/err/0010_wrong_order_fns.txt
@@ -1,9 +1,9 @@
 SOURCE_FILE@[0; 50)
-  ERROR@[0; 5)
-    ASYNC_KW@[0; 5) "async"
-  WHITESPACE@[5; 6) " "
-  FN_DEF@[6; 24)
-    UNSAFE_KW@[6; 12) "unsafe"
+  ERROR@[0; 6)
+    UNSAFE_KW@[0; 6) "unsafe"
+  WHITESPACE@[6; 7) " "
+  FN_DEF@[7; 24)
+    ASYNC_KW@[7; 12) "async"
     WHITESPACE@[12; 13) " "
     FN_KW@[13; 15) "fn"
     WHITESPACE@[15; 16) " "
@@ -37,5 +37,5 @@ SOURCE_FILE@[0; 50)
         L_CURLY@[47; 48) "{"
         R_CURLY@[48; 49) "}"
   WHITESPACE@[49; 50) "\n"
-error 5: expected existential, fn, trait or impl
+error 6: expected existential, fn, trait or impl
 error 31: expected existential, fn, trait or impl
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.rs b/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.rs
index d8c23c76a..93636e926 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.rs
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.rs
@@ -1 +1 @@
-type F = Box<Fn(a: i32, &b: &i32, &mut c: &i32, ())>;
+type F = Box<Fn(i32, &i32, &i32, ())>;
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.txt b/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.txt
index 8cfba8420..9241f6fb2 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0004_value_parameters_no_patterns.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 54)
-  TYPE_ALIAS_DEF@[0; 53)
+SOURCE_FILE@[0; 39)
+  TYPE_ALIAS_DEF@[0; 38)
     TYPE_KW@[0; 4) "type"
     WHITESPACE@[4; 5) " "
     NAME@[5; 6)
@@ -7,75 +7,54 @@ SOURCE_FILE@[0; 54)
     WHITESPACE@[6; 7) " "
     EQ@[7; 8) "="
     WHITESPACE@[8; 9) " "
-    PATH_TYPE@[9; 52)
-      PATH@[9; 52)
-        PATH_SEGMENT@[9; 52)
+    PATH_TYPE@[9; 37)
+      PATH@[9; 37)
+        PATH_SEGMENT@[9; 37)
           NAME_REF@[9; 12)
             IDENT@[9; 12) "Box"
-          TYPE_ARG_LIST@[12; 52)
+          TYPE_ARG_LIST@[12; 37)
             L_ANGLE@[12; 13) "<"
-            TYPE_ARG@[13; 51)
-              PATH_TYPE@[13; 51)
-                PATH@[13; 51)
-                  PATH_SEGMENT@[13; 51)
+            TYPE_ARG@[13; 36)
+              PATH_TYPE@[13; 36)
+                PATH@[13; 36)
+                  PATH_SEGMENT@[13; 36)
                     NAME_REF@[13; 15)
                       IDENT@[13; 15) "Fn"
-                    PARAM_LIST@[15; 51)
+                    PARAM_LIST@[15; 36)
                       L_PAREN@[15; 16) "("
-                      PARAM@[16; 22)
-                        BIND_PAT@[16; 17)
-                          NAME@[16; 17)
-                            IDENT@[16; 17) "a"
-                        COLON@[17; 18) ":"
-                        WHITESPACE@[18; 19) " "
-                        PATH_TYPE@[19; 22)
-                          PATH@[19; 22)
-                            PATH_SEGMENT@[19; 22)
-                              NAME_REF@[19; 22)
-                                IDENT@[19; 22) "i32"
-                      COMMA@[22; 23) ","
-                      WHITESPACE@[23; 24) " "
-                      PARAM@[24; 32)
-                        REF_PAT@[24; 26)
-                          AMP@[24; 25) "&"
-                          BIND_PAT@[25; 26)
-                            NAME@[25; 26)
-                              IDENT@[25; 26) "b"
-                        COLON@[26; 27) ":"
-                        WHITESPACE@[27; 28) " "
-                        REFERENCE_TYPE@[28; 32)
-                          AMP@[28; 29) "&"
-                          PATH_TYPE@[29; 32)
-                            PATH@[29; 32)
-                              PATH_SEGMENT@[29; 32)
-                                NAME_REF@[29; 32)
-                                  IDENT@[29; 32) "i32"
-                      COMMA@[32; 33) ","
-                      WHITESPACE@[33; 34) " "
-                      PARAM@[34; 46)
-                        REF_PAT@[34; 40)
-                          AMP@[34; 35) "&"
-                          MUT_KW@[35; 38) "mut"
-                          WHITESPACE@[38; 39) " "
-                          BIND_PAT@[39; 40)
-                            NAME@[39; 40)
-                              IDENT@[39; 40) "c"
-                        COLON@[40; 41) ":"
-                        WHITESPACE@[41; 42) " "
-                        REFERENCE_TYPE@[42; 46)
-                          AMP@[42; 43) "&"
-                          PATH_TYPE@[43; 46)
-                            PATH@[43; 46)
-                              PATH_SEGMENT@[43; 46)
-                                NAME_REF@[43; 46)
-                                  IDENT@[43; 46) "i32"
-                      COMMA@[46; 47) ","
-                      WHITESPACE@[47; 48) " "
-                      PARAM@[48; 50)
-                        TUPLE_TYPE@[48; 50)
-                          L_PAREN@[48; 49) "("
-                          R_PAREN@[49; 50) ")"
-                      R_PAREN@[50; 51) ")"
-            R_ANGLE@[51; 52) ">"
-    SEMI@[52; 53) ";"
-  WHITESPACE@[53; 54) "\n"
+                      PARAM@[16; 19)
+                        PATH_TYPE@[16; 19)
+                          PATH@[16; 19)
+                            PATH_SEGMENT@[16; 19)
+                              NAME_REF@[16; 19)
+                                IDENT@[16; 19) "i32"
+                      COMMA@[19; 20) ","
+                      WHITESPACE@[20; 21) " "
+                      PARAM@[21; 25)
+                        REFERENCE_TYPE@[21; 25)
+                          AMP@[21; 22) "&"
+                          PATH_TYPE@[22; 25)
+                            PATH@[22; 25)
+                              PATH_SEGMENT@[22; 25)
+                                NAME_REF@[22; 25)
+                                  IDENT@[22; 25) "i32"
+                      COMMA@[25; 26) ","
+                      WHITESPACE@[26; 27) " "
+                      PARAM@[27; 31)
+                        REFERENCE_TYPE@[27; 31)
+                          AMP@[27; 28) "&"
+                          PATH_TYPE@[28; 31)
+                            PATH@[28; 31)
+                              PATH_SEGMENT@[28; 31)
+                                NAME_REF@[28; 31)
+                                  IDENT@[28; 31) "i32"
+                      COMMA@[31; 32) ","
+                      WHITESPACE@[32; 33) " "
+                      PARAM@[33; 35)
+                        TUPLE_TYPE@[33; 35)
+                          L_PAREN@[33; 34) "("
+                          R_PAREN@[34; 35) ")"
+                      R_PAREN@[35; 36) ")"
+            R_ANGLE@[36; 37) ">"
+    SEMI@[37; 38) ";"
+  WHITESPACE@[38; 39) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.rs b/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.rs
index aef45e561..17ed20e5b 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.rs
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.rs
@@ -1 +1 @@
-type F = Box<Fn(x: i32) -> ()>;
+type F = Box<Fn(i32) -> ()>;
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.txt b/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.txt
index d6f196811..a983d5954 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0104_path_fn_trait_args.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 32)
-  TYPE_ALIAS_DEF@[0; 31)
+SOURCE_FILE@[0; 29)
+  TYPE_ALIAS_DEF@[0; 28)
     TYPE_KW@[0; 4) "type"
     WHITESPACE@[4; 5) " "
     NAME@[5; 6)
@@ -7,40 +7,35 @@ SOURCE_FILE@[0; 32)
     WHITESPACE@[6; 7) " "
     EQ@[7; 8) "="
     WHITESPACE@[8; 9) " "
-    PATH_TYPE@[9; 30)
-      PATH@[9; 30)
-        PATH_SEGMENT@[9; 30)
+    PATH_TYPE@[9; 27)
+      PATH@[9; 27)
+        PATH_SEGMENT@[9; 27)
           NAME_REF@[9; 12)
             IDENT@[9; 12) "Box"
-          TYPE_ARG_LIST@[12; 30)
+          TYPE_ARG_LIST@[12; 27)
             L_ANGLE@[12; 13) "<"
-            TYPE_ARG@[13; 29)
-              PATH_TYPE@[13; 29)
-                PATH@[13; 29)
-                  PATH_SEGMENT@[13; 29)
+            TYPE_ARG@[13; 26)
+              PATH_TYPE@[13; 26)
+                PATH@[13; 26)
+                  PATH_SEGMENT@[13; 26)
                     NAME_REF@[13; 15)
                       IDENT@[13; 15) "Fn"
-                    PARAM_LIST@[15; 23)
+                    PARAM_LIST@[15; 20)
                       L_PAREN@[15; 16) "("
-                      PARAM@[16; 22)
-                        BIND_PAT@[16; 17)
-                          NAME@[16; 17)
-                            IDENT@[16; 17) "x"
-                        COLON@[17; 18) ":"
-                        WHITESPACE@[18; 19) " "
-                        PATH_TYPE@[19; 22)
-                          PATH@[19; 22)
-                            PATH_SEGMENT@[19; 22)
-                              NAME_REF@[19; 22)
-                                IDENT@[19; 22) "i32"
-                      R_PAREN@[22; 23) ")"
-                    WHITESPACE@[23; 24) " "
-                    RET_TYPE@[24; 29)
-                      THIN_ARROW@[24; 26) "->"
-                      WHITESPACE@[26; 27) " "
-                      TUPLE_TYPE@[27; 29)
-                        L_PAREN@[27; 28) "("
-                        R_PAREN@[28; 29) ")"
-            R_ANGLE@[29; 30) ">"
-    SEMI@[30; 31) ";"
-  WHITESPACE@[31; 32) "\n"
+                      PARAM@[16; 19)
+                        PATH_TYPE@[16; 19)
+                          PATH@[16; 19)
+                            PATH_SEGMENT@[16; 19)
+                              NAME_REF@[16; 19)
+                                IDENT@[16; 19) "i32"
+                      R_PAREN@[19; 20) ")"
+                    WHITESPACE@[20; 21) " "
+                    RET_TYPE@[21; 26)
+                      THIN_ARROW@[21; 23) "->"
+                      WHITESPACE@[23; 24) " "
+                      TUPLE_TYPE@[24; 26)
+                        L_PAREN@[24; 25) "("
+                        R_PAREN@[25; 26) ")"
+            R_ANGLE@[26; 27) ">"
+    SEMI@[27; 28) ";"
+  WHITESPACE@[28; 29) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.rs b/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.rs
index 46af91b82..126287145 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.rs
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.rs
@@ -1,2 +1,2 @@
-unsafe async fn foo() {}
+async unsafe fn foo() {}
 const unsafe fn bar() {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.txt b/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.txt
index cae75c41d..8a972cdb2 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0128_combined_fns.txt
@@ -1,8 +1,8 @@
 SOURCE_FILE@[0; 50)
   FN_DEF@[0; 24)
-    UNSAFE_KW@[0; 6) "unsafe"
-    WHITESPACE@[6; 7) " "
-    ASYNC_KW@[7; 12) "async"
+    ASYNC_KW@[0; 5) "async"
+    WHITESPACE@[5; 6) " "
+    UNSAFE_KW@[6; 12) "unsafe"
     WHITESPACE@[12; 13) " "
     FN_KW@[13; 15) "fn"
     WHITESPACE@[15; 16) " "
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.rs b/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.rs
new file mode 100644
index 000000000..b49e872d7
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.rs
@@ -0,0 +1,6 @@
+impl U {
+    fn f1((a, b): (usize, usize)) {}
+    fn f2(S { a, b }: S) {}
+    fn f3(NewType(a): NewType) {}
+    fn f4(&&a: &&usize) {}
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.txt b/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.txt
new file mode 100644
index 000000000..933f5b7bd
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.txt
@@ -0,0 +1,164 @@
+SOURCE_FILE@[0; 137)
+  IMPL_BLOCK@[0; 136)
+    IMPL_KW@[0; 4) "impl"
+    WHITESPACE@[4; 5) " "
+    PATH_TYPE@[5; 6)
+      PATH@[5; 6)
+        PATH_SEGMENT@[5; 6)
+          NAME_REF@[5; 6)
+            IDENT@[5; 6) "U"
+    WHITESPACE@[6; 7) " "
+    ITEM_LIST@[7; 136)
+      L_CURLY@[7; 8) "{"
+      WHITESPACE@[8; 13) "\n    "
+      FN_DEF@[13; 45)
+        FN_KW@[13; 15) "fn"
+        WHITESPACE@[15; 16) " "
+        NAME@[16; 18)
+          IDENT@[16; 18) "f1"
+        PARAM_LIST@[18; 42)
+          L_PAREN@[18; 19) "("
+          PARAM@[19; 41)
+            TUPLE_PAT@[19; 25)
+              L_PAREN@[19; 20) "("
+              BIND_PAT@[20; 21)
+                NAME@[20; 21)
+                  IDENT@[20; 21) "a"
+              COMMA@[21; 22) ","
+              WHITESPACE@[22; 23) " "
+              BIND_PAT@[23; 24)
+                NAME@[23; 24)
+                  IDENT@[23; 24) "b"
+              R_PAREN@[24; 25) ")"
+            COLON@[25; 26) ":"
+            WHITESPACE@[26; 27) " "
+            TUPLE_TYPE@[27; 41)
+              L_PAREN@[27; 28) "("
+              PATH_TYPE@[28; 33)
+                PATH@[28; 33)
+                  PATH_SEGMENT@[28; 33)
+                    NAME_REF@[28; 33)
+                      IDENT@[28; 33) "usize"
+              COMMA@[33; 34) ","
+              WHITESPACE@[34; 35) " "
+              PATH_TYPE@[35; 40)
+                PATH@[35; 40)
+                  PATH_SEGMENT@[35; 40)
+                    NAME_REF@[35; 40)
+                      IDENT@[35; 40) "usize"
+              R_PAREN@[40; 41) ")"
+          R_PAREN@[41; 42) ")"
+        WHITESPACE@[42; 43) " "
+        BLOCK_EXPR@[43; 45)
+          BLOCK@[43; 45)
+            L_CURLY@[43; 44) "{"
+            R_CURLY@[44; 45) "}"
+      WHITESPACE@[45; 50) "\n    "
+      FN_DEF@[50; 73)
+        FN_KW@[50; 52) "fn"
+        WHITESPACE@[52; 53) " "
+        NAME@[53; 55)
+          IDENT@[53; 55) "f2"
+        PARAM_LIST@[55; 70)
+          L_PAREN@[55; 56) "("
+          PARAM@[56; 69)
+            RECORD_PAT@[56; 66)
+              PATH@[56; 57)
+                PATH_SEGMENT@[56; 57)
+                  NAME_REF@[56; 57)
+                    IDENT@[56; 57) "S"
+              WHITESPACE@[57; 58) " "
+              RECORD_FIELD_PAT_LIST@[58; 66)
+                L_CURLY@[58; 59) "{"
+                WHITESPACE@[59; 60) " "
+                BIND_PAT@[60; 61)
+                  NAME@[60; 61)
+                    IDENT@[60; 61) "a"
+                COMMA@[61; 62) ","
+                WHITESPACE@[62; 63) " "
+                BIND_PAT@[63; 64)
+                  NAME@[63; 64)
+                    IDENT@[63; 64) "b"
+                WHITESPACE@[64; 65) " "
+                R_CURLY@[65; 66) "}"
+            COLON@[66; 67) ":"
+            WHITESPACE@[67; 68) " "
+            PATH_TYPE@[68; 69)
+              PATH@[68; 69)
+                PATH_SEGMENT@[68; 69)
+                  NAME_REF@[68; 69)
+                    IDENT@[68; 69) "S"
+          R_PAREN@[69; 70) ")"
+        WHITESPACE@[70; 71) " "
+        BLOCK_EXPR@[71; 73)
+          BLOCK@[71; 73)
+            L_CURLY@[71; 72) "{"
+            R_CURLY@[72; 73) "}"
+      WHITESPACE@[73; 78) "\n    "
+      FN_DEF@[78; 107)
+        FN_KW@[78; 80) "fn"
+        WHITESPACE@[80; 81) " "
+        NAME@[81; 83)
+          IDENT@[81; 83) "f3"
+        PARAM_LIST@[83; 104)
+          L_PAREN@[83; 84) "("
+          PARAM@[84; 103)
+            TUPLE_STRUCT_PAT@[84; 94)
+              PATH@[84; 91)
+                PATH_SEGMENT@[84; 91)
+                  NAME_REF@[84; 91)
+                    IDENT@[84; 91) "NewType"
+              L_PAREN@[91; 92) "("
+              BIND_PAT@[92; 93)
+                NAME@[92; 93)
+                  IDENT@[92; 93) "a"
+              R_PAREN@[93; 94) ")"
+            COLON@[94; 95) ":"
+            WHITESPACE@[95; 96) " "
+            PATH_TYPE@[96; 103)
+              PATH@[96; 103)
+                PATH_SEGMENT@[96; 103)
+                  NAME_REF@[96; 103)
+                    IDENT@[96; 103) "NewType"
+          R_PAREN@[103; 104) ")"
+        WHITESPACE@[104; 105) " "
+        BLOCK_EXPR@[105; 107)
+          BLOCK@[105; 107)
+            L_CURLY@[105; 106) "{"
+            R_CURLY@[106; 107) "}"
+      WHITESPACE@[107; 112) "\n    "
+      FN_DEF@[112; 134)
+        FN_KW@[112; 114) "fn"
+        WHITESPACE@[114; 115) " "
+        NAME@[115; 117)
+          IDENT@[115; 117) "f4"
+        PARAM_LIST@[117; 131)
+          L_PAREN@[117; 118) "("
+          PARAM@[118; 130)
+            REF_PAT@[118; 121)
+              AMP@[118; 119) "&"
+              REF_PAT@[119; 121)
+                AMP@[119; 120) "&"
+                BIND_PAT@[120; 121)
+                  NAME@[120; 121)
+                    IDENT@[120; 121) "a"
+            COLON@[121; 122) ":"
+            WHITESPACE@[122; 123) " "
+            REFERENCE_TYPE@[123; 130)
+              AMP@[123; 124) "&"
+              REFERENCE_TYPE@[124; 130)
+                AMP@[124; 125) "&"
+                PATH_TYPE@[125; 130)
+                  PATH@[125; 130)
+                    PATH_SEGMENT@[125; 130)
+                      NAME_REF@[125; 130)
+                        IDENT@[125; 130) "usize"
+          R_PAREN@[130; 131) ")"
+        WHITESPACE@[131; 132) " "
+        BLOCK_EXPR@[132; 134)
+          BLOCK@[132; 134)
+            L_CURLY@[132; 133) "{"
+            R_CURLY@[133; 134) "}"
+      WHITESPACE@[134; 135) "\n"
+      R_CURLY@[135; 136) "}"
+  WHITESPACE@[136; 137) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.rs b/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.rs
new file mode 100644
index 000000000..a94bf378a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.rs
@@ -0,0 +1,6 @@
+trait T {
+    fn f1((a, b): (usize, usize)) {}
+    fn f2(S { a, b }: S) {}
+    fn f3(NewType(a): NewType) {}
+    fn f4(&&a: &&usize) {}
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.txt b/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.txt
new file mode 100644
index 000000000..b22df8dbe
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.txt
@@ -0,0 +1,161 @@
+SOURCE_FILE@[0; 138)
+  TRAIT_DEF@[0; 137)
+    TRAIT_KW@[0; 5) "trait"
+    WHITESPACE@[5; 6) " "
+    NAME@[6; 7)
+      IDENT@[6; 7) "T"
+    WHITESPACE@[7; 8) " "
+    ITEM_LIST@[8; 137)
+      L_CURLY@[8; 9) "{"
+      WHITESPACE@[9; 14) "\n    "
+      FN_DEF@[14; 46)
+        FN_KW@[14; 16) "fn"
+        WHITESPACE@[16; 17) " "
+        NAME@[17; 19)
+          IDENT@[17; 19) "f1"
+        PARAM_LIST@[19; 43)
+          L_PAREN@[19; 20) "("
+          PARAM@[20; 42)
+            TUPLE_PAT@[20; 26)
+              L_PAREN@[20; 21) "("
+              BIND_PAT@[21; 22)
+                NAME@[21; 22)
+                  IDENT@[21; 22) "a"
+              COMMA@[22; 23) ","
+              WHITESPACE@[23; 24) " "
+              BIND_PAT@[24; 25)
+                NAME@[24; 25)
+                  IDENT@[24; 25) "b"
+              R_PAREN@[25; 26) ")"
+            COLON@[26; 27) ":"
+            WHITESPACE@[27; 28) " "
+            TUPLE_TYPE@[28; 42)
+              L_PAREN@[28; 29) "("
+              PATH_TYPE@[29; 34)
+                PATH@[29; 34)
+                  PATH_SEGMENT@[29; 34)
+                    NAME_REF@[29; 34)
+                      IDENT@[29; 34) "usize"
+              COMMA@[34; 35) ","
+              WHITESPACE@[35; 36) " "
+              PATH_TYPE@[36; 41)
+                PATH@[36; 41)
+                  PATH_SEGMENT@[36; 41)
+                    NAME_REF@[36; 41)
+                      IDENT@[36; 41) "usize"
+              R_PAREN@[41; 42) ")"
+          R_PAREN@[42; 43) ")"
+        WHITESPACE@[43; 44) " "
+        BLOCK_EXPR@[44; 46)
+          BLOCK@[44; 46)
+            L_CURLY@[44; 45) "{"
+            R_CURLY@[45; 46) "}"
+      WHITESPACE@[46; 51) "\n    "
+      FN_DEF@[51; 74)
+        FN_KW@[51; 53) "fn"
+        WHITESPACE@[53; 54) " "
+        NAME@[54; 56)
+          IDENT@[54; 56) "f2"
+        PARAM_LIST@[56; 71)
+          L_PAREN@[56; 57) "("
+          PARAM@[57; 70)
+            RECORD_PAT@[57; 67)
+              PATH@[57; 58)
+                PATH_SEGMENT@[57; 58)
+                  NAME_REF@[57; 58)
+                    IDENT@[57; 58) "S"
+              WHITESPACE@[58; 59) " "
+              RECORD_FIELD_PAT_LIST@[59; 67)
+                L_CURLY@[59; 60) "{"
+                WHITESPACE@[60; 61) " "
+                BIND_PAT@[61; 62)
+                  NAME@[61; 62)
+                    IDENT@[61; 62) "a"
+                COMMA@[62; 63) ","
+                WHITESPACE@[63; 64) " "
+                BIND_PAT@[64; 65)
+                  NAME@[64; 65)
+                    IDENT@[64; 65) "b"
+                WHITESPACE@[65; 66) " "
+                R_CURLY@[66; 67) "}"
+            COLON@[67; 68) ":"
+            WHITESPACE@[68; 69) " "
+            PATH_TYPE@[69; 70)
+              PATH@[69; 70)
+                PATH_SEGMENT@[69; 70)
+                  NAME_REF@[69; 70)
+                    IDENT@[69; 70) "S"
+          R_PAREN@[70; 71) ")"
+        WHITESPACE@[71; 72) " "
+        BLOCK_EXPR@[72; 74)
+          BLOCK@[72; 74)
+            L_CURLY@[72; 73) "{"
+            R_CURLY@[73; 74) "}"
+      WHITESPACE@[74; 79) "\n    "
+      FN_DEF@[79; 108)
+        FN_KW@[79; 81) "fn"
+        WHITESPACE@[81; 82) " "
+        NAME@[82; 84)
+          IDENT@[82; 84) "f3"
+        PARAM_LIST@[84; 105)
+          L_PAREN@[84; 85) "("
+          PARAM@[85; 104)
+            TUPLE_STRUCT_PAT@[85; 95)
+              PATH@[85; 92)
+                PATH_SEGMENT@[85; 92)
+                  NAME_REF@[85; 92)
+                    IDENT@[85; 92) "NewType"
+              L_PAREN@[92; 93) "("
+              BIND_PAT@[93; 94)
+                NAME@[93; 94)
+                  IDENT@[93; 94) "a"
+              R_PAREN@[94; 95) ")"
+            COLON@[95; 96) ":"
+            WHITESPACE@[96; 97) " "
+            PATH_TYPE@[97; 104)
+              PATH@[97; 104)
+                PATH_SEGMENT@[97; 104)
+                  NAME_REF@[97; 104)
+                    IDENT@[97; 104) "NewType"
+          R_PAREN@[104; 105) ")"
+        WHITESPACE@[105; 106) " "
+        BLOCK_EXPR@[106; 108)
+          BLOCK@[106; 108)
+            L_CURLY@[106; 107) "{"
+            R_CURLY@[107; 108) "}"
+      WHITESPACE@[108; 113) "\n    "
+      FN_DEF@[113; 135)
+        FN_KW@[113; 115) "fn"
+        WHITESPACE@[115; 116) " "
+        NAME@[116; 118)
+          IDENT@[116; 118) "f4"
+        PARAM_LIST@[118; 132)
+          L_PAREN@[118; 119) "("
+          PARAM@[119; 131)
+            REF_PAT@[119; 122)
+              AMP@[119; 120) "&"
+              REF_PAT@[120; 122)
+                AMP@[120; 121) "&"
+                BIND_PAT@[121; 122)
+                  NAME@[121; 122)
+                    IDENT@[121; 122) "a"
+            COLON@[122; 123) ":"
+            WHITESPACE@[123; 124) " "
+            REFERENCE_TYPE@[124; 131)
+              AMP@[124; 125) "&"
+              REFERENCE_TYPE@[125; 131)
+                AMP@[125; 126) "&"
+                PATH_TYPE@[126; 131)
+                  PATH@[126; 131)
+                    PATH_SEGMENT@[126; 131)
+                      NAME_REF@[126; 131)
+                        IDENT@[126; 131) "usize"
+          R_PAREN@[131; 132) ")"
+        WHITESPACE@[132; 133) " "
+        BLOCK_EXPR@[133; 135)
+          BLOCK@[133; 135)
+            L_CURLY@[133; 134) "{"
+            R_CURLY@[134; 135) "}"
+      WHITESPACE@[135; 136) "\n"
+      R_CURLY@[136; 137) "}"
+  WHITESPACE@[137; 138) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rs b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rs
new file mode 100644
index 000000000..80a1701fd
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.rs
@@ -0,0 +1,2 @@
+type Foo = fn(Bar::Baz);
+type Qux = fn(baz: Bar::Baz);
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.txt b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.txt
new file mode 100644
index 000000000..cb686854a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0154_fn_pointer_param_ident_path.txt
@@ -0,0 +1,58 @@
+SOURCE_FILE@[0; 55)
+  TYPE_ALIAS_DEF@[0; 24)
+    TYPE_KW@[0; 4) "type"
+    WHITESPACE@[4; 5) " "
+    NAME@[5; 8)
+      IDENT@[5; 8) "Foo"
+    WHITESPACE@[8; 9) " "
+    EQ@[9; 10) "="
+    WHITESPACE@[10; 11) " "
+    FN_POINTER_TYPE@[11; 23)
+      FN_KW@[11; 13) "fn"
+      PARAM_LIST@[13; 23)
+        L_PAREN@[13; 14) "("
+        PARAM@[14; 22)
+          PATH_TYPE@[14; 22)
+            PATH@[14; 22)
+              PATH@[14; 17)
+                PATH_SEGMENT@[14; 17)
+                  NAME_REF@[14; 17)
+                    IDENT@[14; 17) "Bar"
+              COLONCOLON@[17; 19) "::"
+              PATH_SEGMENT@[19; 22)
+                NAME_REF@[19; 22)
+                  IDENT@[19; 22) "Baz"
+        R_PAREN@[22; 23) ")"
+    SEMI@[23; 24) ";"
+  WHITESPACE@[24; 25) "\n"
+  TYPE_ALIAS_DEF@[25; 54)
+    TYPE_KW@[25; 29) "type"
+    WHITESPACE@[29; 30) " "
+    NAME@[30; 33)
+      IDENT@[30; 33) "Qux"
+    WHITESPACE@[33; 34) " "
+    EQ@[34; 35) "="
+    WHITESPACE@[35; 36) " "
+    FN_POINTER_TYPE@[36; 53)
+      FN_KW@[36; 38) "fn"
+      PARAM_LIST@[38; 53)
+        L_PAREN@[38; 39) "("
+        PARAM@[39; 52)
+          BIND_PAT@[39; 42)
+            NAME@[39; 42)
+              IDENT@[39; 42) "baz"
+          COLON@[42; 43) ":"
+          WHITESPACE@[43; 44) " "
+          PATH_TYPE@[44; 52)
+            PATH@[44; 52)
+              PATH@[44; 47)
+                PATH_SEGMENT@[44; 47)
+                  NAME_REF@[44; 47)
+                    IDENT@[44; 47) "Bar"
+              COLONCOLON@[47; 49) "::"
+              PATH_SEGMENT@[49; 52)
+                NAME_REF@[49; 52)
+                  IDENT@[49; 52) "Baz"
+        R_PAREN@[52; 53) ")"
+    SEMI@[53; 54) ";"
+  WHITESPACE@[54; 55) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rs b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rs
new file mode 100644
index 000000000..6ca8dd2d6
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.rs
@@ -0,0 +1,3 @@
+fn main() {
+   let foo = |bar, baz: Baz, qux: Qux::Quux| ();
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.txt b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.txt
new file mode 100644
index 000000000..98727ae98
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0155_closure_params.txt
@@ -0,0 +1,70 @@
+SOURCE_FILE@[0; 63)
+  FN_DEF@[0; 62)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 62)
+      BLOCK@[10; 62)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 15) "\n   "
+        LET_STMT@[15; 60)
+          LET_KW@[15; 18) "let"
+          WHITESPACE@[18; 19) " "
+          BIND_PAT@[19; 22)
+            NAME@[19; 22)
+              IDENT@[19; 22) "foo"
+          WHITESPACE@[22; 23) " "
+          EQ@[23; 24) "="
+          WHITESPACE@[24; 25) " "
+          LAMBDA_EXPR@[25; 59)
+            PARAM_LIST@[25; 56)
+              PIPE@[25; 26) "|"
+              PARAM@[26; 29)
+                BIND_PAT@[26; 29)
+                  NAME@[26; 29)
+                    IDENT@[26; 29) "bar"
+              COMMA@[29; 30) ","
+              WHITESPACE@[30; 31) " "
+              PARAM@[31; 39)
+                BIND_PAT@[31; 34)
+                  NAME@[31; 34)
+                    IDENT@[31; 34) "baz"
+                COLON@[34; 35) ":"
+                WHITESPACE@[35; 36) " "
+                PATH_TYPE@[36; 39)
+                  PATH@[36; 39)
+                    PATH_SEGMENT@[36; 39)
+                      NAME_REF@[36; 39)
+                        IDENT@[36; 39) "Baz"
+              COMMA@[39; 40) ","
+              WHITESPACE@[40; 41) " "
+              PARAM@[41; 55)
+                BIND_PAT@[41; 44)
+                  NAME@[41; 44)
+                    IDENT@[41; 44) "qux"
+                COLON@[44; 45) ":"
+                WHITESPACE@[45; 46) " "
+                PATH_TYPE@[46; 55)
+                  PATH@[46; 55)
+                    PATH@[46; 49)
+                      PATH_SEGMENT@[46; 49)
+                        NAME_REF@[46; 49)
+                          IDENT@[46; 49) "Qux"
+                    COLONCOLON@[49; 51) "::"
+                    PATH_SEGMENT@[51; 55)
+                      NAME_REF@[51; 55)
+                        IDENT@[51; 55) "Quux"
+              PIPE@[55; 56) "|"
+            WHITESPACE@[56; 57) " "
+            TUPLE_EXPR@[57; 59)
+              L_PAREN@[57; 58) "("
+              R_PAREN@[58; 59) ")"
+          SEMI@[59; 60) ";"
+        WHITESPACE@[60; 61) "\n"
+        R_CURLY@[61; 62) "}"
+  WHITESPACE@[62; 63) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0030_traits.rs b/crates/ra_syntax/test_data/parser/ok/0030_traits.rs
index 23c4be0e1..ac30843ef 100644
--- a/crates/ra_syntax/test_data/parser/ok/0030_traits.rs
+++ b/crates/ra_syntax/test_data/parser/ok/0030_traits.rs
@@ -1,7 +1,3 @@
-pub trait WriteMessage {
-    fn write_message(&FrontendMessage);
-}
-
 trait Runnable {
     fn handler();
 }
diff --git a/crates/ra_syntax/test_data/parser/ok/0030_traits.txt b/crates/ra_syntax/test_data/parser/ok/0030_traits.txt
index b656c1a81..ac314ae50 100644
--- a/crates/ra_syntax/test_data/parser/ok/0030_traits.txt
+++ b/crates/ra_syntax/test_data/parser/ok/0030_traits.txt
@@ -1,93 +1,61 @@
-SOURCE_FILE@[0; 164)
-  TRAIT_DEF@[0; 66)
-    VISIBILITY@[0; 3)
-      PUB_KW@[0; 3) "pub"
-    WHITESPACE@[3; 4) " "
-    TRAIT_KW@[4; 9) "trait"
-    WHITESPACE@[9; 10) " "
-    NAME@[10; 22)
-      IDENT@[10; 22) "WriteMessage"
-    WHITESPACE@[22; 23) " "
-    ITEM_LIST@[23; 66)
-      L_CURLY@[23; 24) "{"
-      WHITESPACE@[24; 29) "\n    "
-      FN_DEF@[29; 64)
-        FN_KW@[29; 31) "fn"
-        WHITESPACE@[31; 32) " "
-        NAME@[32; 45)
-          IDENT@[32; 45) "write_message"
-        PARAM_LIST@[45; 63)
-          L_PAREN@[45; 46) "("
-          PARAM@[46; 62)
-            REFERENCE_TYPE@[46; 62)
-              AMP@[46; 47) "&"
-              PATH_TYPE@[47; 62)
-                PATH@[47; 62)
-                  PATH_SEGMENT@[47; 62)
-                    NAME_REF@[47; 62)
-                      IDENT@[47; 62) "FrontendMessage"
-          R_PAREN@[62; 63) ")"
-        SEMI@[63; 64) ";"
-      WHITESPACE@[64; 65) "\n"
-      R_CURLY@[65; 66) "}"
-  WHITESPACE@[66; 68) "\n\n"
-  TRAIT_DEF@[68; 104)
-    TRAIT_KW@[68; 73) "trait"
-    WHITESPACE@[73; 74) " "
-    NAME@[74; 82)
-      IDENT@[74; 82) "Runnable"
-    WHITESPACE@[82; 83) " "
-    ITEM_LIST@[83; 104)
-      L_CURLY@[83; 84) "{"
-      WHITESPACE@[84; 89) "\n    "
-      FN_DEF@[89; 102)
-        FN_KW@[89; 91) "fn"
-        WHITESPACE@[91; 92) " "
-        NAME@[92; 99)
-          IDENT@[92; 99) "handler"
-        PARAM_LIST@[99; 101)
-          L_PAREN@[99; 100) "("
-          R_PAREN@[100; 101) ")"
-        SEMI@[101; 102) ";"
-      WHITESPACE@[102; 103) "\n"
-      R_CURLY@[103; 104) "}"
-  WHITESPACE@[104; 106) "\n\n"
-  TRAIT_DEF@[106; 163)
-    TRAIT_KW@[106; 111) "trait"
-    WHITESPACE@[111; 112) " "
-    NAME@[112; 125)
-      IDENT@[112; 125) "TraitWithExpr"
-    WHITESPACE@[125; 126) " "
-    ITEM_LIST@[126; 163)
-      L_CURLY@[126; 127) "{"
-      WHITESPACE@[127; 132) "\n    "
-      FN_DEF@[132; 161)
-        FN_KW@[132; 134) "fn"
-        WHITESPACE@[134; 135) " "
-        NAME@[135; 147)
-          IDENT@[135; 147) "fn_with_expr"
-        PARAM_LIST@[147; 160)
-          L_PAREN@[147; 148) "("
-          PARAM@[148; 159)
-            BIND_PAT@[148; 149)
-              NAME@[148; 149)
-                IDENT@[148; 149) "x"
-            COLON@[149; 150) ":"
-            WHITESPACE@[150; 151) " "
-            ARRAY_TYPE@[151; 159)
-              L_BRACK@[151; 152) "["
-              PATH_TYPE@[152; 155)
-                PATH@[152; 155)
-                  PATH_SEGMENT@[152; 155)
-                    NAME_REF@[152; 155)
-                      IDENT@[152; 155) "i32"
-              SEMI@[155; 156) ";"
-              WHITESPACE@[156; 157) " "
-              LITERAL@[157; 158)
-                INT_NUMBER@[157; 158) "1"
-              R_BRACK@[158; 159) "]"
-          R_PAREN@[159; 160) ")"
-        SEMI@[160; 161) ";"
-      WHITESPACE@[161; 162) "\n"
-      R_CURLY@[162; 163) "}"
-  WHITESPACE@[163; 164) "\n"
+SOURCE_FILE@[0; 96)
+  TRAIT_DEF@[0; 36)
+    TRAIT_KW@[0; 5) "trait"
+    WHITESPACE@[5; 6) " "
+    NAME@[6; 14)
+      IDENT@[6; 14) "Runnable"
+    WHITESPACE@[14; 15) " "
+    ITEM_LIST@[15; 36)
+      L_CURLY@[15; 16) "{"
+      WHITESPACE@[16; 21) "\n    "
+      FN_DEF@[21; 34)
+        FN_KW@[21; 23) "fn"
+        WHITESPACE@[23; 24) " "
+        NAME@[24; 31)
+          IDENT@[24; 31) "handler"
+        PARAM_LIST@[31; 33)
+          L_PAREN@[31; 32) "("
+          R_PAREN@[32; 33) ")"
+        SEMI@[33; 34) ";"
+      WHITESPACE@[34; 35) "\n"
+      R_CURLY@[35; 36) "}"
+  WHITESPACE@[36; 38) "\n\n"
+  TRAIT_DEF@[38; 95)
+    TRAIT_KW@[38; 43) "trait"
+    WHITESPACE@[43; 44) " "
+    NAME@[44; 57)
+      IDENT@[44; 57) "TraitWithExpr"
+    WHITESPACE@[57; 58) " "
+    ITEM_LIST@[58; 95)
+      L_CURLY@[58; 59) "{"
+      WHITESPACE@[59; 64) "\n    "
+      FN_DEF@[64; 93)
+        FN_KW@[64; 66) "fn"
+        WHITESPACE@[66; 67) " "
+        NAME@[67; 79)
+          IDENT@[67; 79) "fn_with_expr"
+        PARAM_LIST@[79; 92)
+          L_PAREN@[79; 80) "("
+          PARAM@[80; 91)
+            BIND_PAT@[80; 81)
+              NAME@[80; 81)
+                IDENT@[80; 81) "x"
+            COLON@[81; 82) ":"
+            WHITESPACE@[82; 83) " "
+            ARRAY_TYPE@[83; 91)
+              L_BRACK@[83; 84) "["
+              PATH_TYPE@[84; 87)
+                PATH@[84; 87)
+                  PATH_SEGMENT@[84; 87)
+                    NAME_REF@[84; 87)
+                      IDENT@[84; 87) "i32"
+              SEMI@[87; 88) ";"
+              WHITESPACE@[88; 89) " "
+              LITERAL@[89; 90)
+                INT_NUMBER@[89; 90) "1"
+              R_BRACK@[90; 91) "]"
+          R_PAREN@[91; 92) ")"
+        SEMI@[92; 93) ";"
+      WHITESPACE@[93; 94) "\n"
+      R_CURLY@[94; 95) "}"
+  WHITESPACE@[95; 96) "\n"
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 659f77b71..336c594a6 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -21,6 +21,12 @@ pub use difference::Changeset as __Changeset;
 
 pub const CURSOR_MARKER: &str = "<|>";
 
+/// Asserts that two strings are equal, otherwise displays a rich diff between them.
+///
+/// The diff shows changes from the "original" left string to the "actual" right string.
+///
+/// All arguments starting from and including the 3rd one are passed to
+/// `eprintln!()` macro in case of text inequality.
 #[macro_export]
 macro_rules! assert_eq_text {
     ($left:expr, $right:expr) => {
@@ -42,6 +48,7 @@ macro_rules! assert_eq_text {
     }};
 }
 
+/// Infallible version of `try_extract_offset()`.
 pub fn extract_offset(text: &str) -> (TextUnit, String) {
     match try_extract_offset(text) {
         None => panic!("text should contain cursor marker"),
@@ -49,6 +56,8 @@ pub fn extract_offset(text: &str) -> (TextUnit, String) {
     }
 }
 
+/// Returns the offset of the first occurence of `<|>` marker and the copy of `text`
+/// without the marker.
 fn try_extract_offset(text: &str) -> Option<(TextUnit, String)> {
     let cursor_pos = text.find(CURSOR_MARKER)?;
     let mut new_text = String::with_capacity(text.len() - CURSOR_MARKER.len());
@@ -58,6 +67,7 @@ fn try_extract_offset(text: &str) -> Option<(TextUnit, String)> {
     Some((cursor_pos, new_text))
 }
 
+/// Infallible version of `try_extract_range()`.
 pub fn extract_range(text: &str) -> (TextRange, String) {
     match try_extract_range(text) {
         None => panic!("text should contain cursor marker"),
@@ -65,6 +75,8 @@ pub fn extract_range(text: &str) -> (TextRange, String) {
     }
 }
 
+/// Returns `TextRange` between the first two markers `<|>...<|>` and the copy
+/// of `text` without both of these markers.
 fn try_extract_range(text: &str) -> Option<(TextRange, String)> {
     let (start, text) = try_extract_offset(text)?;
     let (end, text) = try_extract_offset(&text)?;
@@ -85,6 +97,11 @@ impl From<RangeOrOffset> for TextRange {
     }
 }
 
+/// Extracts `TextRange` or `TextUnit` depending on the amount of `<|>` markers
+/// found in `text`.
+///
+/// # Panics
+/// Panics if no `<|>` marker is present in the `text`.
 pub fn extract_range_or_offset(text: &str) -> (RangeOrOffset, String) {
     if let Some((range, text)) = try_extract_range(text) {
         return (RangeOrOffset::Range(range), text);
@@ -93,7 +110,7 @@ pub fn extract_range_or_offset(text: &str) -> (RangeOrOffset, String) {
     (RangeOrOffset::Offset(offset), text)
 }
 
-/// Extracts ranges, marked with `<tag> </tag>` paris from the `text`
+/// Extracts ranges, marked with `<tag> </tag>` pairs from the `text`
 pub fn extract_ranges(mut text: &str, tag: &str) -> (Vec<TextRange>, String) {
     let open = format!("<{}>", tag);
     let close = format!("</{}>", tag);
@@ -127,9 +144,9 @@ pub fn extract_ranges(mut text: &str, tag: &str) -> (Vec<TextRange>, String) {
     (ranges, res)
 }
 
+/// Inserts `<|>` marker into the `text` at `offset`.
 pub fn add_cursor(text: &str, offset: TextUnit) -> String {
-    let offset: u32 = offset.into();
-    let offset: usize = offset as usize;
+    let offset: usize = offset.to_usize();
     let mut res = String::new();
     res.push_str(&text[..offset]);
     res.push_str("<|>");
@@ -152,19 +169,6 @@ pub struct FixtureEntry {
 ///  // - other meta
 ///  ```
 pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
-    let mut res = Vec::new();
-    let mut buf = String::new();
-    let mut meta: Option<&str> = None;
-
-    macro_rules! flush {
-        () => {
-            if let Some(meta) = meta {
-                res.push(FixtureEntry { meta: meta.to_string(), text: buf.clone() });
-                buf.clear();
-            }
-        };
-    };
-
     let margin = fixture
         .lines()
         .filter(|it| it.trim_start().starts_with("//-"))
@@ -172,7 +176,7 @@ pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
         .next()
         .expect("empty fixture");
 
-    let lines = fixture
+    let mut lines = fixture
         .split('\n') // don't use `.lines` to not drop `\r\n`
         .filter_map(|line| {
             if line.len() >= margin {
@@ -184,17 +188,16 @@ pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
             }
         });
 
-    for line in lines {
+    let mut res: Vec<FixtureEntry> = Vec::new();
+    for line in lines.by_ref() {
         if line.starts_with("//-") {
-            flush!();
-            buf.clear();
-            meta = Some(line["//-".len()..].trim());
-            continue;
+            let meta = line["//-".len()..].trim().to_string();
+            res.push(FixtureEntry { meta, text: String::new() })
+        } else if let Some(entry) = res.last_mut() {
+            entry.text.push_str(line);
+            entry.text.push('\n');
         }
-        buf.push_str(line);
-        buf.push('\n');
     }
-    flush!();
     res
 }
 
@@ -236,11 +239,10 @@ fn lines_match_works() {
     assert!(!lines_match("b", "cb"));
 }
 
-// Compares JSON object for approximate equality.
-// You can use `[..]` wildcard in strings (useful for OS dependent things such
-// as paths).  You can use a `"{...}"` string literal as a wildcard for
-// arbitrary nested JSON (useful for parts of object emitted by other programs
-// (e.g. rustc) rather than Cargo itself).  Arrays are sorted before comparison.
+/// Compares JSON object for approximate equality.
+/// You can use `[..]` wildcard in strings (useful for OS dependent things such
+/// as paths). You can use a `"{...}"` string literal as a wildcard for
+/// arbitrary nested JSON. Arrays are sorted before comparison.
 pub fn find_mismatch<'a>(expected: &'a Value, actual: &'a Value) -> Option<(&'a Value, &'a Value)> {
     use serde_json::Value::*;
     match (expected, actual) {
@@ -286,6 +288,14 @@ pub fn find_mismatch<'a>(expected: &'a Value, actual: &'a Value) -> Option<(&'a
     }
 }
 
+/// Calls callback `f` with input code and file paths of all `.rs` files from `test_data_dir`
+/// subdirectories defined by `paths`.
+///
+/// If the content of the matching `.txt` file differs from the output of `f()`
+/// the test will fail.
+///
+/// If there is no matching `.txt` file it will be created and filled with the
+/// output of `f()`, but the test will fail.
 pub fn dir_tests<F>(test_data_dir: &Path, paths: &[&str], f: F)
 where
     F: Fn(&str, &Path) -> String,
@@ -307,6 +317,7 @@ where
     }
 }
 
+/// Collects all `.rs` files from `test_data_dir` subdirectories defined by `paths`.
 pub fn collect_tests(test_data_dir: &Path, paths: &[&str]) -> Vec<(PathBuf, String)> {
     paths
         .iter()
@@ -321,6 +332,7 @@ pub fn collect_tests(test_data_dir: &Path, paths: &[&str]) -> Vec<(PathBuf, Stri
         .collect()
 }
 
+/// Collects paths to all `.rs` files from `dir` in a sorted `Vec<PathBuf>`.
 fn test_from_dir(dir: &Path) -> Vec<PathBuf> {
     let mut acc = Vec::new();
     for file in fs::read_dir(&dir).unwrap() {
@@ -334,6 +346,7 @@ fn test_from_dir(dir: &Path) -> Vec<PathBuf> {
     acc
 }
 
+/// Returns the path to the root directory of `rust-analyzer` project.
 pub fn project_dir() -> PathBuf {
     let dir = env!("CARGO_MANIFEST_DIR");
     PathBuf::from(dir).parent().unwrap().parent().unwrap().to_owned()
@@ -356,6 +369,9 @@ pub fn read_text(path: &Path) -> String {
         .replace("\r\n", "\n")
 }
 
+/// Returns `false` if slow tests should not run, otherwise returns `true` and
+/// also creates a file at `./target/.slow_tests_cookie` which serves as a flag
+/// that slow tests did run.
 pub fn skip_slow_tests() -> bool {
     let should_skip = std::env::var("CI").is_err() && std::env::var("RUN_SLOW_TESTS").is_err();
     if should_skip {
@@ -367,8 +383,9 @@ pub fn skip_slow_tests() -> bool {
     should_skip
 }
 
-const REWRITE: bool = false;
-
+/// Asserts that `expected` and `actual` strings are equal. If they differ only
+/// in trailing or leading whitespace the test won't fail and
+/// the contents of `actual` will be written to the file located at `path`.
 fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
     if expected == actual {
         return;
@@ -381,6 +398,7 @@ fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
         fs::write(path, actual).unwrap();
         return;
     }
+    const REWRITE: bool = false;
     if REWRITE {
         println!("rewriting {}", pretty_path.display());
         fs::write(path, actual).unwrap();
diff --git a/crates/test_utils/src/marks.rs b/crates/test_utils/src/marks.rs
index fe1813947..f8fabfaff 100644
--- a/crates/test_utils/src/marks.rs
+++ b/crates/test_utils/src/marks.rs
@@ -1,4 +1,4 @@
-//! This module implements manually tracked test coverage, which useful for
+//! This module implements manually tracked test coverage, which is useful for
 //! quickly finding a test responsible for testing a particular bit of code.
 //!
 //! See <https://matklad.github.io/2018/06/18/a-trick-for-test-maintenance.html>