45 files changed, 1760 insertions, 1393 deletions
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
index 3085c4330..a680f752b 100644
--- a/crates/ra_assists/src/assist_context.rs
+++ b/crates/ra_assists/src/assist_context.rs
@@ -49,7 +49,7 @@ use crate::{Assist, AssistId, GroupLabel, ResolvedAssist};
 /// easier to just compute the edit eagerly :-)
 pub(crate) struct AssistContext<'a> {
    pub(crate) sema: Semantics<'a, RootDatabase>,
-    pub(super) db: &'a RootDatabase,
+    pub(crate) db: &'a RootDatabase,
    pub(crate) frange: FileRange,
    source_file: SourceFile,
 }
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 55409e501..7ced00626 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -23,6 +23,7 @@ use crate::{AssistContext, AssistId, Assists};
 // ```
 pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let stmt = ctx.find_node_at_offset::<LetStmt>()?;
+    let module = ctx.sema.scope(stmt.syntax()).module()?;
    let expr = stmt.initializer()?;
    let pat = stmt.pat()?;
    // Must be a binding
@@ -57,17 +58,17 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
        return None;
    }
-    let db = ctx.db;
+    let inferred_type = ty.display_source_code(ctx.db, module.into()).ok()?;
-    let new_type_string = ty.display_truncated(db, None).to_string();
    acc.add(
        AssistId("add_explicit_type"),
-        format!("Insert explicit type '{}'", new_type_string),
+        format!("Insert explicit type '{}'", inferred_type),
        pat_range,
-        |edit| {
+        |builder| match ascribed_ty {
-            if let Some(ascribed_ty) = ascribed_ty {
+            Some(ascribed_ty) => {
-                edit.replace(ascribed_ty.syntax().text_range(), new_type_string);
+                builder.replace(ascribed_ty.syntax().text_range(), inferred_type);
-            } else {
+            }
-                edit.insert(name_range.end(), format!(": {}", new_type_string));
+            None => {
+                builder.insert(name_range.end(), format!(": {}", inferred_type));
            }
        },
    )
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
index 275184e24..6a49b7dbd 100644
--- a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -1,8 +1,5 @@
 use ra_ide_db::RootDatabase;
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode, NameOwner};
-    ast::{self, AstNode, NameOwner},
-    TextSize,
-};
 use stdx::format_to;
 use test_utils::tested_by;
@@ -69,7 +66,6 @@ impl From<{0}> for {1} {{
                variant_name
            );
            edit.insert(start_offset, buf);
-            edit.set_cursor(start_offset + TextSize::of("\n\n"));
        },
    )
 }
@@ -97,19 +93,20 @@ fn existing_from_impl(
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use test_utils::covers;
    use crate::tests::{check_assist, check_assist_not_applicable};
-    use test_utils::covers;
+    use super::*;
    #[test]
    fn test_add_from_impl_for_enum() {
        check_assist(
            add_from_impl_for_enum,
            "enum A { <|>One(u32) }",
-            r#"enum A { One(u32) }
+            r#"enum A { <|>One(u32) }
-<|>impl From<u32> for A {
+impl From<u32> for A {
    fn from(v: u32) -> Self {
        A::One(v)
    }
@@ -121,10 +118,10 @@ mod tests {
    fn test_add_from_impl_for_enum_complicated_path() {
        check_assist(
            add_from_impl_for_enum,
-            "enum A { <|>One(foo::bar::baz::Boo) }",
+            r#"enum A { <|>One(foo::bar::baz::Boo) }"#,
-            r#"enum A { One(foo::bar::baz::Boo) }
+            r#"enum A { <|>One(foo::bar::baz::Boo) }
-<|>impl From<foo::bar::baz::Boo> for A {
+impl From<foo::bar::baz::Boo> for A {
    fn from(v: foo::bar::baz::Boo) -> Self {
        A::One(v)
    }
@@ -184,9 +181,9 @@ impl From<String> for A {
 pub trait From<T> {
    fn from(T) -> Self;
 }"#,
-            r#"enum A { One(u32), Two(String), }
+            r#"enum A { <|>One(u32), Two(String), }
-<|>impl From<u32> for A {
+impl From<u32> for A {
    fn from(v: u32) -> Self {
        A::One(v)
    }
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index 6b5616aa9..de016ae4e 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -1,7 +1,11 @@
 use hir::HirDisplay;
 use ra_db::FileId;
 use ra_syntax::{
-    ast::{self, edit::IndentLevel, ArgListOwner, AstNode, ModuleItemOwner},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        ArgListOwner, AstNode, ModuleItemOwner,
+    },
    SyntaxKind, SyntaxNode, TextSize,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -43,16 +47,12 @@ pub(crate) fn add_function(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
        return None;
    }
-    let target_module = if let Some(qualifier) = path.qualifier() {
+    let target_module = match path.qualifier() {
-        if let Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) =
+        Some(qualifier) => match ctx.sema.resolve_path(&qualifier) {
-            ctx.sema.resolve_path(&qualifier)
+            Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) => Some(module),
-        {
+            _ => return None,
-            Some(module.definition_source(ctx.sema.db))
+        },
-        } else {
+        None => None,
-            return None;
-        }
-    } else {
-        None
    };
    let function_builder = FunctionBuilder::from_call(&ctx, &call, &path, target_module)?;
@@ -83,25 +83,29 @@ struct FunctionBuilder {
 }
 impl FunctionBuilder {
-    /// Prepares a generated function that matches `call` in `generate_in`
+    /// Prepares a generated function that matches `call`.
-    /// (or as close to `call` as possible, if `generate_in` is `None`)
+    /// The function is generated in `target_module` or next to `call`
    fn from_call(
        ctx: &AssistContext,
        call: &ast::CallExpr,
        path: &ast::Path,
-        target_module: Option<hir::InFile<hir::ModuleSource>>,
+        target_module: Option<hir::Module>,
    ) -> Option<Self> {
-        let needs_pub = target_module.is_some();
        let mut file = ctx.frange.file_id;
-        let target = if let Some(target_module) = target_module {
+        let target = match &target_module {
-            let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, target_module)?;
+            Some(target_module) => {
-            file = in_file;
+                let module_source = target_module.definition_source(ctx.db);
-            target
+                let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, &module_source)?;
-        } else {
+                file = in_file;
-            next_space_for_fn_after_call_site(&call)?
+                target
+            }
+            None => next_space_for_fn_after_call_site(&call)?,
        };
+        let needs_pub = target_module.is_some();
+        let target_module = target_module.or_else(|| ctx.sema.scope(target.syntax()).module())?;
        let fn_name = fn_name(&path)?;
-        let (type_params, params) = fn_args(ctx, &call)?;
+        let (type_params, params) = fn_args(ctx, target_module, &call)?;
        Some(Self { target, fn_name, type_params, params, file, needs_pub })
    }
@@ -116,17 +120,16 @@ impl FunctionBuilder {
        let (fn_def, insert_offset) = match self.target {
            GeneratedFunctionTarget::BehindItem(it) => {
                let with_leading_blank_line = ast::make::add_leading_newlines(2, fn_def);
-                let indented = IndentLevel::from_node(&it).increase_indent(with_leading_blank_line);
+                let indented = with_leading_blank_line.indent(IndentLevel::from_node(&it));
                (indented, it.text_range().end())
            }
            GeneratedFunctionTarget::InEmptyItemList(it) => {
                let indent_once = IndentLevel(1);
                let indent = IndentLevel::from_node(it.syntax());
                let fn_def = ast::make::add_leading_newlines(1, fn_def);
-                let fn_def = indent_once.increase_indent(fn_def);
+                let fn_def = fn_def.indent(indent_once);
                let fn_def = ast::make::add_trailing_newlines(1, fn_def);
-                let fn_def = indent.increase_indent(fn_def);
+                let fn_def = fn_def.indent(indent);
                (fn_def, it.syntax().text_range().start() + TextSize::of('{'))
            }
        };
@@ -144,6 +147,15 @@ enum GeneratedFunctionTarget {
    InEmptyItemList(ast::ItemList),
 }
+impl GeneratedFunctionTarget {
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            GeneratedFunctionTarget::BehindItem(it) => it,
+            GeneratedFunctionTarget::InEmptyItemList(it) => it.syntax(),
+        }
+    }
+}
 fn fn_name(call: &ast::Path) -> Option<ast::Name> {
    let name = call.segment()?.syntax().to_string();
    Some(ast::make::name(&name))
@@ -152,17 +164,17 @@ fn fn_name(call: &ast::Path) -> Option<ast::Name> {
 /// Computes the type variables and arguments required for the generated function
 fn fn_args(
    ctx: &AssistContext,
+    target_module: hir::Module,
    call: &ast::CallExpr,
 ) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
    let mut arg_names = Vec::new();
    let mut arg_types = Vec::new();
    for arg in call.arg_list()?.args() {
-        let arg_name = match fn_arg_name(&arg) {
+        arg_names.push(match fn_arg_name(&arg) {
            Some(name) => name,
            None => String::from("arg"),
-        };
+        });
-        arg_names.push(arg_name);
+        arg_types.push(match fn_arg_type(ctx, target_module, &arg) {
-        arg_types.push(match fn_arg_type(ctx, &arg) {
            Some(ty) => ty,
            None => String::from("()"),
        });
@@ -218,12 +230,21 @@ fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> {
    }
 }
-fn fn_arg_type(ctx: &AssistContext, fn_arg: &ast::Expr) -> Option<String> {
+fn fn_arg_type(
+    ctx: &AssistContext,
+    target_module: hir::Module,
+    fn_arg: &ast::Expr,
+) -> Option<String> {
    let ty = ctx.sema.type_of_expr(fn_arg)?;
    if ty.is_unknown() {
        return None;
    }
-    Some(ty.display(ctx.sema.db).to_string())
+    if let Ok(rendered) = ty.display_source_code(ctx.db, target_module.into()) {
+        Some(rendered)
+    } else {
+        None
+    }
 }
 /// Returns the position inside the current mod or file
@@ -252,10 +273,10 @@ fn next_space_for_fn_after_call_site(expr: &ast::CallExpr) -> Option<GeneratedFu
 fn next_space_for_fn_in_module(
    db: &dyn hir::db::AstDatabase,
-    module: hir::InFile<hir::ModuleSource>,
+    module_source: &hir::InFile<hir::ModuleSource>,
 ) -> Option<(FileId, GeneratedFunctionTarget)> {
-    let file = module.file_id.original_file(db);
+    let file = module_source.file_id.original_file(db);
-    let assist_item = match module.value {
+    let assist_item = match &module_source.value {
        hir::ModuleSource::SourceFile(it) => {
            if let Some(last_item) = it.items().last() {
                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
@@ -599,8 +620,33 @@ fn bar(foo: impl Foo) {
    }
    #[test]
-    #[ignore]
+    fn borrowed_arg() {
-    // FIXME print paths properly to make this test pass
+        check_assist(
+            add_function,
+            r"
+struct Baz;
+fn baz() -> Baz { todo!() }
+fn foo() {
+    bar<|>(&baz())
+}
+",
+            r"
+struct Baz;
+fn baz() -> Baz { todo!() }
+fn foo() {
+    bar(&baz())
+}
+fn bar(baz: &Baz) {
+    <|>todo!()
+}
+",
+        )
+    }
+    #[test]
    fn add_function_with_qualified_path_arg() {
        check_assist(
            add_function,
@@ -609,10 +655,8 @@ mod Baz {
    pub struct Bof;
    pub fn baz() -> Bof { Bof }
 }
-mod Foo {
+fn foo() {
-    fn foo() {
+    <|>bar(Baz::baz())
-        <|>bar(super::Baz::baz())
-    }
 }
 ",
            r"
@@ -620,14 +664,12 @@ mod Baz {
    pub struct Bof;
    pub fn baz() -> Bof { Bof }
 }
-mod Foo {
+fn foo() {
-    fn foo() {
+    bar(Baz::baz())
-        bar(super::Baz::baz())
+}
-    }
-    fn bar(baz: super::Baz::Bof) {
+fn bar(baz: Baz::Bof) {
-        <|>todo!()
+    <|>todo!()
-    }
 }
 ",
        )
@@ -809,6 +851,40 @@ fn foo() {
    }
    #[test]
+    #[ignore]
+    // Ignored until local imports are supported.
+    // See https://github.com/rust-analyzer/rust-analyzer/issues/1165
+    fn qualified_path_uses_correct_scope() {
+        check_assist(
+            add_function,
+            "
+mod foo {
+    pub struct Foo;
+}
+fn bar() {
+    use foo::Foo;
+    let foo = Foo;
+    baz<|>(foo)
+}
+",
+            "
+mod foo {
+    pub struct Foo;
+}
+fn bar() {
+    use foo::Foo;
+    let foo = Foo;
+    baz(foo)
+}
+fn baz(foo: foo::Foo) {
+    <|>todo!()
+}
+",
+        )
+    }
+    #[test]
    fn add_function_in_module_containing_other_items() {
        check_assist(
            add_function,
@@ -920,21 +996,6 @@ fn bar(baz: ()) {}
    }
    #[test]
-    fn add_function_not_applicable_if_function_path_not_singleton() {
-        // In the future this assist could be extended to generate functions
-        // if the path is in the same crate (or even the same workspace).
-        // For the beginning, I think this is fine.
-        check_assist_not_applicable(
-            add_function,
-            r"
-fn foo() {
-    other_crate::bar<|>();
-}
-        ",
-        )
-    }
-    #[test]
    #[ignore]
    fn create_method_with_no_args() {
        check_assist(
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 3482a75bf..c1ce87914 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -2,7 +2,7 @@ use hir::HasSource;
 use ra_syntax::{
    ast::{
        self,
-        edit::{self, IndentLevel},
+        edit::{self, AstNodeEdit, IndentLevel},
        make, AstNode, NameOwner,
    },
    SmolStr,
@@ -176,8 +176,7 @@ fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
    if fn_def.body().is_some() {
        return fn_def;
    }
-    let body = make::block_expr(None, Some(make::expr_todo()));
+    let body = make::block_expr(None, Some(make::expr_todo())).indent(IndentLevel(1));
-    let body = IndentLevel(1).increase_indent(body);
    fn_def.with_body(body)
 }
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 810784ad5..66b296081 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -2,7 +2,11 @@ use std::{iter::once, ops::RangeInclusive};
 use ra_syntax::{
    algo::replace_children,
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
    SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
    SyntaxNode,
@@ -105,8 +109,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                    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(make::condition(cond, None), then_branch);
+                    make::expr_if(make::condition(cond, None), then_branch).indent(if_indent_level)
-                    if_indent_level.increase_indent(e)
                };
                replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
            }
@@ -140,7 +143,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                    make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
                    Some(match_expr),
                );
-                let let_stmt = if_indent_level.increase_indent(let_stmt);
+                let let_stmt = let_stmt.indent(if_indent_level);
                replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
            }
        };
@@ -153,7 +156,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
            parent_block: &ast::BlockExpr,
            if_expr: &ast::IfExpr,
        ) -> SyntaxNode {
-            let then_block_items = IndentLevel::from(1).decrease_indent(then_block.clone());
+            let then_block_items = then_block.dedent(IndentLevel::from(1));
            let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
            let end_of_then =
                if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
diff --git a/crates/ra_assists/src/handlers/replace_if_let_with_match.rs b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
index a59a06efa..65f5fc6ab 100644
--- a/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
@@ -1,6 +1,10 @@
 use ra_fmt::unwrap_trivial_block;
 use ra_syntax::{
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
 };
@@ -61,10 +65,9 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext)
                make::match_arm(vec![pattern], else_expr)
            };
            make::expr_match(expr, make::match_arm_list(vec![then_arm, else_arm]))
+                .indent(IndentLevel::from_node(if_expr.syntax()))
        };
-        let match_expr = IndentLevel::from_node(if_expr.syntax()).increase_indent(match_expr);
        edit.set_cursor(if_expr.syntax().text_range().start());
        edit.replace_ast::<ast::Expr>(if_expr.into(), match_expr);
    })
diff --git a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
index d3f214591..482957dc6 100644
--- a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
@@ -53,8 +53,7 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) ->
            )
            .into(),
        };
-        let block =
+        let block = make::block_expr(None, None).indent(IndentLevel::from_node(let_stmt.syntax()));
-            IndentLevel::from_node(let_stmt.syntax()).increase_indent(make::block_expr(None, None));
        let if_ = make::expr_if(make::condition(init, Some(with_placeholder)), block);
        let stmt = make::expr_stmt(if_);
diff --git a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
index a46998b8e..c4b56f6e9 100644
--- a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
@@ -1,7 +1,11 @@
 use std::iter;
 use ra_syntax::{
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
 };
@@ -51,8 +55,8 @@ pub(crate) fn replace_unwrap_with_match(acc: &mut Assists, ctx: &AssistContext)
        let err_arm = make::match_arm(iter::once(make::placeholder_pat().into()), unreachable_call);
        let match_arm_list = make::match_arm_list(vec![ok_arm, err_arm]);
-        let match_expr = make::expr_match(caller.clone(), match_arm_list);
+        let match_expr = make::expr_match(caller.clone(), match_arm_list)
-        let match_expr = IndentLevel::from_node(method_call.syntax()).increase_indent(match_expr);
+            .indent(IndentLevel::from_node(method_call.syntax()));
        edit.set_cursor(caller.syntax().text_range().start());
        edit.replace_ast::<ast::Expr>(method_call.into(), match_expr);
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index eba0631a4..e52ec557e 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,6 +1,6 @@
 use crate::{AssistContext, AssistId, Assists};
-use ast::LoopBodyOwner;
+use ast::{ElseBranch, Expr, LoopBodyOwner};
 use ra_fmt::unwrap_trivial_block;
 use ra_syntax::{ast, match_ast, AstNode, TextRange, T};
@@ -25,19 +25,11 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
    let block = ast::BlockExpr::cast(l_curly_token.parent())?;
    let parent = block.syntax().parent()?;
+    let assist_id = AssistId("unwrap_block");
+    let assist_label = "Unwrap block";
    let (expr, expr_to_unwrap) = match_ast! {
        match parent {
-            ast::IfExpr(if_expr) => {
-                let expr_to_unwrap = if_expr.blocks().find_map(|expr| extract_expr(ctx.frange.range, expr));
-                let expr_to_unwrap = expr_to_unwrap?;
-                // Find if we are in a else if block
-                let ancestor = if_expr.syntax().parent().and_then(ast::IfExpr::cast);
-                match ancestor {
-                    None => (ast::Expr::IfExpr(if_expr), expr_to_unwrap),
-                    Some(ancestor) => (ast::Expr::IfExpr(ancestor), expr_to_unwrap),
-                }
-            },
            ast::ForExpr(for_expr) => {
                let block_expr = for_expr.loop_body()?;
                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
@@ -53,27 +45,62 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
                (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap)
            },
+            ast::IfExpr(if_expr) => {
+                let mut resp = None;
+                let then_branch = if_expr.then_branch()?;
+                if then_branch.l_curly_token()?.text_range().contains_range(ctx.frange.range) {
+                    if let Some(ancestor) = if_expr.syntax().parent().and_then(ast::IfExpr::cast) {
+                        // For `else if` blocks
+                        let ancestor_then_branch = ancestor.then_branch()?;
+                        let l_curly_token = then_branch.l_curly_token()?;
+                        let target = then_branch.syntax().text_range();
+                        return acc.add(assist_id, assist_label, target, |edit| {
+                            let range_to_del_else_if = TextRange::new(ancestor_then_branch.syntax().text_range().end(), l_curly_token.text_range().start());
+                            let range_to_del_rest = TextRange::new(then_branch.syntax().text_range().end(), if_expr.syntax().text_range().end());
+                            edit.set_cursor(ancestor_then_branch.syntax().text_range().end());
+                            edit.delete(range_to_del_rest);
+                            edit.delete(range_to_del_else_if);
+                            edit.replace(target, update_expr_string(then_branch.to_string(), &[' ', '{']));
+                        });
+                    } else {
+                        resp = Some((ast::Expr::IfExpr(if_expr.clone()), Expr::BlockExpr(then_branch)));
+                    }
+                } else if let Some(else_branch) = if_expr.else_branch() {
+                    match else_branch {
+                        ElseBranch::Block(else_block) => {
+                            let l_curly_token = else_block.l_curly_token()?;
+                            if l_curly_token.text_range().contains_range(ctx.frange.range) {
+                                let target = else_block.syntax().text_range();
+                                return acc.add(assist_id, assist_label, target, |edit| {
+                                    let range_to_del = TextRange::new(then_branch.syntax().text_range().end(), l_curly_token.text_range().start());
+                                    edit.set_cursor(then_branch.syntax().text_range().end());
+                                    edit.delete(range_to_del);
+                                    edit.replace(target, update_expr_string(else_block.to_string(), &[' ', '{']));
+                                });
+                            }
+                        },
+                        ElseBranch::IfExpr(_) => {},
+                    }
+                }
+                resp?
+            },
            _ => return None,
        }
    };
    let target = expr_to_unwrap.syntax().text_range();
-    acc.add(AssistId("unwrap_block"), "Unwrap block", target, |edit| {
+    acc.add(assist_id, assist_label, target, |edit| {
        edit.set_cursor(expr.syntax().text_range().start());
-        let pat_start: &[_] = &[' ', '{', '\n'];
+        edit.replace(
-        let expr_to_unwrap = expr_to_unwrap.to_string();
+            expr.syntax().text_range(),
-        let expr_string = expr_to_unwrap.trim_start_matches(pat_start);
+            update_expr_string(expr_to_unwrap.to_string(), &[' ', '{', '\n']),
-        let mut expr_string_lines: Vec<&str> = expr_string.lines().collect();
+        );
-        expr_string_lines.pop(); // Delete last line
-        let expr_string = expr_string_lines
-            .into_iter()
-            .map(|line| line.replacen("    ", "", 1)) // Delete indentation
-            .collect::<Vec<String>>()
-            .join("\n");
-        edit.replace(expr.syntax().text_range(), expr_string);
    })
 }
@@ -87,6 +114,18 @@ fn extract_expr(cursor_range: TextRange, block: ast::BlockExpr) -> Option<ast::E
    }
 }
+fn update_expr_string(expr_str: String, trim_start_pat: &[char]) -> String {
+    let expr_string = expr_str.trim_start_matches(trim_start_pat);
+    let mut expr_string_lines: Vec<&str> = expr_string.lines().collect();
+    expr_string_lines.pop(); // Delete last line
+    expr_string_lines
+        .into_iter()
+        .map(|line| line.replacen("    ", "", 1)) // Delete indentation
+        .collect::<Vec<String>>()
+        .join("\n")
+}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -142,7 +181,13 @@ mod tests {
            r#"
            fn main() {
                bar();
-                <|>println!("bar");
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                }<|>
+                println!("bar");
            }
            "#,
        );
@@ -170,7 +215,127 @@ mod tests {
            r#"
            fn main() {
                //bar();
-                <|>println!("bar");
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                }<|>
+                println!("bar");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {<|>
+                    println!("foo");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                }<|>
+                println!("foo");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {
+                    println!("foo");
+                } else {<|>
+                    println!("else");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {
+                    println!("foo");
+                }<|>
+                println!("else");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested_middle() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {<|>
+                    println!("foo");
+                } else {
+                    println!("else");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                }<|>
+                println!("foo");
            }
            "#,
        );
diff --git a/crates/ra_flycheck/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index 03e557148..eac502da5 100644
--- a/crates/ra_flycheck/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 crossbeam-channel = "0.4.0"
 lsp-types = { version = "0.74.0", features = ["proposed"] }
 log = "0.4.8"
-cargo_metadata = "0.9.1"
+cargo_metadata = "0.10.0"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 ra_toolchain = { path = "../ra_toolchain" }
diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index 68dcee285..24af75c95 100644
--- a/crates/ra_flycheck/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -204,6 +204,8 @@ impl FlycheckThread {
            }
            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
+            CheckEvent::Msg(Message::BuildFinished(_)) => {}
+            CheckEvent::Msg(Message::TextLine(_)) => {}
            CheckEvent::Msg(Message::Unknown) => {}
        }
    }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 5f480c304..3fc2eccdd 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -22,8 +22,11 @@ use hir_expand::{
    MacroDefId, MacroDefKind,
 };
 use hir_ty::{
-    autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
+    autoderef,
-    Canonical, InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
+    display::{HirDisplayError, HirFormatter},
+    expr::ExprValidator,
+    method_resolution, ApplicationTy, Canonical, InEnvironment, Substs, TraitEnvironment, Ty,
+    TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, CrateName, Edition, FileId};
 use ra_prof::profile;
@@ -675,6 +678,10 @@ impl Static {
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.static_data(self.id).name.clone()
    }
+    pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
+        db.static_data(self.id).mutable
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1319,7 +1326,7 @@ impl Type {
 }
 impl HirDisplay for Type {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> std::fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        self.ty.value.hir_fmt(f)
    }
 }
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index e7eb2bb11..e2130d931 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -251,11 +251,6 @@ impl ConstData {
        Arc::new(ConstData::new(db, vis_default, node))
    }
-    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, RawVisibility::private(), node))
-    }
    fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
        db: &dyn DefDatabase,
        vis_default: RawVisibility,
@@ -270,6 +265,32 @@ impl ConstData {
    }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StaticData {
+    pub name: Option<Name>,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
+    pub mutable: bool,
+}
+impl StaticData {
+    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
+        let node = konst.lookup(db).source(db);
+        let ctx = LowerCtx::new(db, node.file_id);
+        let name = node.value.name().map(|n| n.as_name());
+        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
+        let mutable = node.value.mut_token().is_some();
+        let visibility = RawVisibility::from_ast_with_default(
+            db,
+            RawVisibility::private(),
+            node.map(|n| n.visibility()),
+        );
+        Arc::new(StaticData { name, type_ref, visibility, mutable })
+    }
+}
 fn collect_items_in_macros(
    db: &dyn DefDatabase,
    expander: &mut Expander,
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 5dc7395f5..e665ab45d 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -10,7 +10,7 @@ use crate::{
    adt::{EnumData, StructData},
    attr::Attrs,
    body::{scope::ExprScopes, Body, BodySourceMap},
-    data::{ConstData, FunctionData, ImplData, TraitData, TypeAliasData},
+    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
    docs::Documentation,
    generics::GenericParams,
    lang_item::{LangItemTarget, LangItems},
@@ -77,8 +77,8 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(ConstData::const_data_query)]
    fn const_data(&self, konst: ConstId) -> Arc<ConstData>;
-    #[salsa::invoke(ConstData::static_data_query)]
+    #[salsa::invoke(StaticData::static_data_query)]
-    fn static_data(&self, konst: StaticId) -> Arc<ConstData>;
+    fn static_data(&self, konst: StaticId) -> Arc<StaticData>;
    #[salsa::invoke(Body::body_with_source_map_query)]
    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index d03bbd5a7..b9c4d2e89 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -6,28 +6,42 @@ use crate::{
    db::HirDatabase, utils::generics, ApplicationTy, CallableDef, FnSig, GenericPredicate,
    Obligation, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
-use hir_def::{generics::TypeParamProvenance, AdtId, AssocContainerId, Lookup};
+use hir_def::{
+    find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId, AssocContainerId,
+    Lookup, ModuleId,
+};
 use hir_expand::name::Name;
-pub struct HirFormatter<'a, 'b> {
+pub struct HirFormatter<'a> {
    pub db: &'a dyn HirDatabase,
-    fmt: &'a mut fmt::Formatter<'b>,
+    fmt: &'a mut dyn fmt::Write,
    buf: String,
    curr_size: usize,
    pub(crate) max_size: Option<usize>,
    omit_verbose_types: bool,
+    display_target: DisplayTarget,
 }
 pub trait HirDisplay {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result;
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError>;
+    /// Returns a `Display`able type that is human-readable.
+    /// Use this for showing types to the user (e.g. diagnostics)
    fn display<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self>
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, None, false)
+        HirDisplayWrapper {
+            db,
+            t: self,
+            max_size: None,
+            omit_verbose_types: false,
+            display_target: DisplayTarget::Diagnostics,
+        }
    }
+    /// Returns a `Display`able type that is human-readable and tries to be succinct.
+    /// Use this for showing types to the user where space is constrained (e.g. doc popups)
    fn display_truncated<'a>(
        &'a self,
        db: &'a dyn HirDatabase,
@@ -36,16 +50,46 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, max_size, true)
+        HirDisplayWrapper {
+            db,
+            t: self,
+            max_size,
+            omit_verbose_types: true,
+            display_target: DisplayTarget::Diagnostics,
+        }
+    }
+    /// Returns a String representation of `self` that can be inserted into the given module.
+    /// Use this when generating code (e.g. assists)
+    fn display_source_code<'a>(
+        &'a self,
+        db: &'a dyn HirDatabase,
+        module_id: ModuleId,
+    ) -> Result<String, DisplaySourceCodeError> {
+        let mut result = String::new();
+        match self.hir_fmt(&mut HirFormatter {
+            db,
+            fmt: &mut result,
+            buf: String::with_capacity(20),
+            curr_size: 0,
+            max_size: None,
+            omit_verbose_types: false,
+            display_target: DisplayTarget::SourceCode { module_id },
+        }) {
+            Ok(()) => {}
+            Err(HirDisplayError::FmtError) => panic!("Writing to String can't fail!"),
+            Err(HirDisplayError::DisplaySourceCodeError(e)) => return Err(e),
+        };
+        Ok(result)
    }
 }
-impl<'a, 'b> HirFormatter<'a, 'b> {
+impl<'a> HirFormatter<'a> {
    pub fn write_joined<T: HirDisplay>(
        &mut self,
        iter: impl IntoIterator<Item = T>,
        sep: &str,
-    ) -> fmt::Result {
+    ) -> Result<(), HirDisplayError> {
        let mut first = true;
        for e in iter {
            if !first {
@@ -58,14 +102,14 @@ impl<'a, 'b> HirFormatter<'a, 'b> {
    }
    /// This allows using the `write!` macro directly with a `HirFormatter`.
-    pub fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+    pub fn write_fmt(&mut self, args: fmt::Arguments) -> Result<(), HirDisplayError> {
        // We write to a buffer first to track output size
        self.buf.clear();
        fmt::write(&mut self.buf, args)?;
        self.curr_size += self.buf.len();
        // Then we write to the internal formatter from the buffer
-        self.fmt.write_str(&self.buf)
+        self.fmt.write_str(&self.buf).map_err(HirDisplayError::from)
    }
    pub fn should_truncate(&self) -> bool {
@@ -81,34 +125,82 @@ impl<'a, 'b> HirFormatter<'a, 'b> {
    }
 }
-pub struct HirDisplayWrapper<'a, T>(&'a dyn HirDatabase, &'a T, Option<usize>, bool);
+#[derive(Clone, Copy)]
+enum DisplayTarget {
+    /// Display types for inlays, doc popups, autocompletion, etc...
+    /// Showing `{unknown}` or not qualifying paths is fine here.
+    /// There's no reason for this to fail.
+    Diagnostics,
+    /// Display types for inserting them in source files.
+    /// The generated code should compile, so paths need to be qualified.
+    SourceCode { module_id: ModuleId },
+}
+impl DisplayTarget {
+    fn is_source_code(&self) -> bool {
+        matches!(self, Self::SourceCode {..})
+    }
+}
+#[derive(Debug)]
+pub enum DisplaySourceCodeError {
+    PathNotFound,
+}
+pub enum HirDisplayError {
+    /// Errors that can occur when generating source code
+    DisplaySourceCodeError(DisplaySourceCodeError),
+    /// `FmtError` is required to be compatible with std::fmt::Display
+    FmtError,
+}
+impl From<fmt::Error> for HirDisplayError {
+    fn from(_: fmt::Error) -> Self {
+        Self::FmtError
+    }
+}
+pub struct HirDisplayWrapper<'a, T> {
+    db: &'a dyn HirDatabase,
+    t: &'a T,
+    max_size: Option<usize>,
+    omit_verbose_types: bool,
+    display_target: DisplayTarget,
+}
 impl<'a, T> fmt::Display for HirDisplayWrapper<'a, T>
 where
    T: HirDisplay,
 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.1.hir_fmt(&mut HirFormatter {
+        match self.t.hir_fmt(&mut HirFormatter {
-            db: self.0,
+            db: self.db,
            fmt: f,
            buf: String::with_capacity(20),
            curr_size: 0,
-            max_size: self.2,
+            max_size: self.max_size,
-            omit_verbose_types: self.3,
+            omit_verbose_types: self.omit_verbose_types,
-        })
+            display_target: self.display_target,
+        }) {
+            Ok(()) => Ok(()),
+            Err(HirDisplayError::FmtError) => Err(fmt::Error),
+            Err(HirDisplayError::DisplaySourceCodeError(_)) => {
+                // This should never happen
+                panic!("HirDisplay failed when calling Display::fmt!")
+            }
+        }
    }
 }
 const TYPE_HINT_TRUNCATION: &str = "…";
 impl HirDisplay for &Ty {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        HirDisplay::hir_fmt(*self, f)
    }
 }
 impl HirDisplay for ApplicationTy {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
@@ -191,45 +283,66 @@ impl HirDisplay for ApplicationTy {
                }
            }
            TypeCtor::Adt(def_id) => {
-                let name = match def_id {
+                match f.display_target {
-                    AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
+                    DisplayTarget::Diagnostics => {
-                    AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
+                        let name = match def_id {
-                    AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
+                            AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
-                };
+                            AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
-                write!(f, "{}", name)?;
+                            AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
+                        };
+                        write!(f, "{}", name)?;
+                    }
+                    DisplayTarget::SourceCode { module_id } => {
+                        if let Some(path) = find_path::find_path(
+                            f.db.upcast(),
+                            ItemInNs::Types(def_id.into()),
+                            module_id,
+                        ) {
+                            write!(f, "{}", path)?;
+                        } else {
+                            return Err(HirDisplayError::DisplaySourceCodeError(
+                                DisplaySourceCodeError::PathNotFound,
+                            ));
+                        }
+                    }
+                }
                if self.parameters.len() > 0 {
                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
-                    let parameters_to_write = if f.omit_verbose_types() {
+                    let parameters_to_write =
-                        match self
+                        if f.display_target.is_source_code() || f.omit_verbose_types() {
-                            .ctor
+                            match self
-                            .as_generic_def()
+                                .ctor
-                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
+                                .as_generic_def()
-                            .filter(|defaults| !defaults.is_empty())
+                                .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
-                        {
+                                .filter(|defaults| !defaults.is_empty())
-                            None => self.parameters.0.as_ref(),
+                            {
-                            Some(default_parameters) => {
+                                None => self.parameters.0.as_ref(),
-                                for (i, parameter) in self.parameters.iter().enumerate() {
+                                Some(default_parameters) => {
-                                    match (parameter, default_parameters.get(i)) {
+                                    for (i, parameter) in self.parameters.iter().enumerate() {
-                                        (&Ty::Unknown, _) | (_, None) => {
+                                        match (parameter, default_parameters.get(i)) {
-                                            non_default_parameters.push(parameter.clone())
+                                            (&Ty::Unknown, _) | (_, None) => {
+                                                non_default_parameters.push(parameter.clone())
+                                            }
+                                            (_, Some(default_parameter))
+                                                if parameter != default_parameter =>
+                                            {
+                                                non_default_parameters.push(parameter.clone())
+                                            }
+                                            _ => (),
                                        }
-                                        (_, Some(default_parameter))
-                                            if parameter != default_parameter =>
-                                        {
-                                            non_default_parameters.push(parameter.clone())
-                                        }
-                                        _ => (),
                                    }
+                                    &non_default_parameters
                                }
-                                &non_default_parameters
                            }
-                        }
+                        } else {
-                    } else {
+                            self.parameters.0.as_ref()
-                        self.parameters.0.as_ref()
+                        };
-                    };
+                    if !parameters_to_write.is_empty() {
-                    write!(f, "<")?;
+                        write!(f, "<")?;
-                    f.write_joined(parameters_to_write, ", ")?;
+                        f.write_joined(parameters_to_write, ", ")?;
-                    write!(f, ">")?;
+                        write!(f, ">")?;
+                    }
                }
            }
            TypeCtor::AssociatedType(type_alias) => {
@@ -269,7 +382,7 @@ impl HirDisplay for ApplicationTy {
 }
 impl HirDisplay for ProjectionTy {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
@@ -287,7 +400,7 @@ impl HirDisplay for ProjectionTy {
 }
 impl HirDisplay for Ty {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
@@ -332,7 +445,7 @@ impl HirDisplay for Ty {
 fn write_bounds_like_dyn_trait(
    predicates: &[GenericPredicate],
    f: &mut HirFormatter,
-) -> fmt::Result {
+) -> Result<(), HirDisplayError> {
    // 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
@@ -394,7 +507,7 @@ fn write_bounds_like_dyn_trait(
 }
 impl TraitRef {
-    fn hir_fmt_ext(&self, f: &mut HirFormatter, use_as: bool) -> fmt::Result {
+    fn hir_fmt_ext(&self, f: &mut HirFormatter, use_as: bool) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
@@ -416,19 +529,19 @@ impl TraitRef {
 }
 impl HirDisplay for TraitRef {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        self.hir_fmt_ext(f, false)
    }
 }
 impl HirDisplay for &GenericPredicate {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        HirDisplay::hir_fmt(*self, f)
    }
 }
 impl HirDisplay for GenericPredicate {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
@@ -452,15 +565,15 @@ impl HirDisplay for GenericPredicate {
 }
 impl HirDisplay for Obligation {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        match self {
+        Ok(match self {
-            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db)),
+            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db))?,
            Obligation::Projection(proj) => write!(
                f,
                "Normalize({} => {})",
                proj.projection_ty.display(f.db),
                proj.ty.display(f.db)
-            ),
+            )?,
-        }
+        })
    }
 }
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index a21ad8d86..fb7c6cd8c 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -22,7 +22,7 @@ use rustc_hash::FxHashMap;
 use hir_def::{
    body::Body,
-    data::{ConstData, FunctionData},
+    data::{ConstData, FunctionData, StaticData},
    expr::{BindingAnnotation, ExprId, PatId},
    lang_item::LangItemTarget,
    path::{path, Path},
@@ -71,7 +71,7 @@ pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer
    match def {
        DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)),
        DefWithBodyId::FunctionId(f) => ctx.collect_fn(&db.function_data(f)),
-        DefWithBodyId::StaticId(s) => ctx.collect_const(&db.static_data(s)),
+        DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_data(s)),
    }
    ctx.infer_body();
@@ -485,6 +485,10 @@ impl<'a> InferenceContext<'a> {
        self.return_ty = self.make_ty(&data.type_ref);
    }
+    fn collect_static(&mut self, data: &StaticData) {
+        self.return_ty = self.make_ty(&data.type_ref);
+    }
    fn collect_fn(&mut self, data: &FunctionData) {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
diff --git a/crates/ra_hir_ty/src/op.rs b/crates/ra_hir_ty/src/op.rs
index 54e2bd05a..0870874fc 100644
--- a/crates/ra_hir_ty/src/op.rs
+++ b/crates/ra_hir_ty/src/op.rs
@@ -30,7 +30,8 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
    match op {
        BinaryOp::LogicOp(..) => Ty::simple(TypeCtor::Bool),
-        BinaryOp::Assignment { op: None } | BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty {
+        BinaryOp::Assignment { op: None } => lhs_ty,
+        BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty {
            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
                TypeCtor::Int(..)
                | TypeCtor::Float(..)
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 5af88b368..1fe05c70c 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -6,6 +6,7 @@ mod patterns;
 mod traits;
 mod method_resolution;
 mod macros;
+mod display_source_code;
 use std::sync::Arc;
@@ -16,7 +17,7 @@ use hir_def::{
    item_scope::ItemScope,
    keys,
    nameres::CrateDefMap,
-    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
+    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
 };
 use hir_expand::{db::AstDatabase, InFile};
 use insta::assert_snapshot;
@@ -37,6 +38,18 @@ use crate::{
 // update the snapshots.
 fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
+    type_at_pos_displayed(db, pos, |ty, _| ty.display(db).to_string())
+}
+fn displayed_source_at_pos(db: &TestDB, pos: FilePosition) -> String {
+    type_at_pos_displayed(db, pos, |ty, module_id| ty.display_source_code(db, module_id).unwrap())
+}
+fn type_at_pos_displayed(
+    db: &TestDB,
+    pos: FilePosition,
+    display_fn: impl FnOnce(&Ty, ModuleId) -> String,
+) -> String {
    let file = db.parse(pos.file_id).ok().unwrap();
    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
    let fn_def = expr.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
@@ -49,7 +62,7 @@ fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
    if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
        let infer = db.infer(func.into());
        let ty = &infer[expr_id];
-        return ty.display(db).to_string();
+        return display_fn(ty, module);
    }
    panic!("Can't find expression")
 }
diff --git a/crates/ra_hir_ty/src/tests/display_source_code.rs b/crates/ra_hir_ty/src/tests/display_source_code.rs
new file mode 100644
index 000000000..4088b1d22
--- /dev/null
+++ b/crates/ra_hir_ty/src/tests/display_source_code.rs
@@ -0,0 +1,50 @@
+use super::displayed_source_at_pos;
+use crate::test_db::TestDB;
+use ra_db::fixture::WithFixture;
+#[test]
+fn qualify_path_to_submodule() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs
+mod foo {
+    pub struct Foo;
+}
+fn bar() {
+    let foo: foo::Foo = foo::Foo;
+    foo<|>
+}
+"#,
+    );
+    assert_eq!("foo::Foo", displayed_source_at_pos(&db, pos));
+}
+#[test]
+fn omit_default_type_parameters() {
+    let (db, pos) = TestDB::with_position(
+        r"
+        //- /main.rs
+        struct Foo<T = u8> { t: T }
+        fn main() {
+            let foo = Foo { t: 5 };
+            foo<|>;
+        }
+        ",
+    );
+    assert_eq!("Foo", displayed_source_at_pos(&db, pos));
+    let (db, pos) = TestDB::with_position(
+        r"
+        //- /main.rs
+        struct Foo<K, T = u8> { k: K, t: T }
+        fn main() {
+            let foo = Foo { k: 400, t: 5 };
+            foo<|>;
+        }
+        ",
+    );
+    assert_eq!("Foo<i32>", displayed_source_at_pos(&db, pos));
+}
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 3820175f6..322838f02 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1787,3 +1787,32 @@ fn main() {
    "###
    )
 }
+#[test]
+fn infer_generic_from_later_assignment() {
+    assert_snapshot!(
+        infer(r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn test() {
+    let mut end = None;
+    loop {
+        end = Some(true);
+    }
+}
+"#),
+        @r###"
+    60..130 '{     ...   } }': ()
+    70..77 'mut end': Option<bool>
+    80..84 'None': Option<bool>
+    90..128 'loop {...     }': !
+    95..128 '{     ...     }': ()
+    105..108 'end': Option<bool>
+    105..121 'end = ...(true)': ()
+    111..115 'Some': Some<bool>(bool) -> Option<bool>
+    111..121 'Some(true)': Option<bool>
+    116..120 'true': bool
+    "###
+    );
+}
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index f16d42276..9572debd8 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -84,8 +84,8 @@ impl FunctionSignature {
            let ty = field.signature_ty(db);
            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1) {
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type[1..].to_string());
+                parameter_types.push(param_type.to_string());
            } else {
                // useful when you have tuple struct
                parameter_types.push(raw_param.clone());
@@ -129,8 +129,8 @@ impl FunctionSignature {
        for field in variant.fields(db).into_iter() {
            let ty = field.signature_ty(db);
            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1) {
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type[1..].to_string());
+                parameter_types.push(param_type.to_string());
            } else {
                // The unwrap_or_else is useful when you have tuple
                parameter_types.push(raw_param);
@@ -197,7 +197,12 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                    let raw_param = self_param.syntax().text().to_string();
                    res_types.push(
-                        raw_param.split(':').nth(1).unwrap_or_else(|| " Self")[1..].to_string(),
+                        raw_param
+                            .split(':')
+                            .nth(1)
+                            .and_then(|it| it.get(1..))
+                            .unwrap_or_else(|| "Self")
+                            .to_string(),
                    );
                    res.push(raw_param);
                }
@@ -205,8 +210,8 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
                res_types.extend(param_list.params().map(|param| {
                    let param_text = param.syntax().text().to_string();
-                    match param_text.split(':').nth(1) {
+                    match param_text.split(':').nth(1).and_then(|it| it.get(1..)) {
-                        Some(it) => it[1..].to_string(),
+                        Some(it) => it.to_string(),
                        None => param_text,
                    }
                }));
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index de35c6711..5da28edd2 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::FileSymbol;
+use crate::{FileRange, FileSymbol};
 use super::short_label::ShortLabel;
@@ -22,10 +22,11 @@ use super::short_label::ShortLabel;
 /// code, like a function or a struct, but this is not strictly required.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
+    // FIXME: use FileRange?
    file_id: FileId,
+    full_range: TextRange,
    name: SmolStr,
    kind: SyntaxKind,
-    full_range: TextRange,
    focus_range: Option<TextRange>,
    container_name: Option<SmolStr>,
    description: Option<String>,
@@ -63,6 +64,10 @@ impl NavigationTarget {
        self.file_id
    }
+    pub fn file_range(&self) -> FileRange {
+        FileRange { file_id: self.file_id, range: self.full_range }
+    }
    pub fn full_range(&self) -> TextRange {
        self.full_range
    }
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index de06daf72..752b487e8 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -27,13 +27,13 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
 </style>
-<pre><code><span class="macro">macro_rules!</span> println {
+<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> {
    ($($arg:tt)*) =&gt; ({
        $<span class="keyword">crate</span>::io::_print($<span class="keyword">crate</span>::format_args_nl!($($arg)*));
    })
 }
 #[rustc_builtin_macro]
-<span class="macro">macro_rules!</span> format_args_nl {
+<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> {
    ($fmt:expr) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
    ($fmt:expr, $($args:tt)*) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
 }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 4b12fe823..4c27aade4 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -33,11 +33,13 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
 }
+<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span>: <span class="builtin_type">i32</span> = <span class="numeric_literal">0</span>;
 <span class="keyword">fn</span> <span class="function declaration">foo</span>&lt;<span class="lifetime declaration">'a</span>, <span class="type_param declaration">T</span>&gt;() -&gt; <span class="type_param">T</span> {
    <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;()
 }
-<span class="macro">macro_rules!</span> def_fn {
+<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> {
    ($($tt:tt)*) =&gt; {$($tt)*}
 }
@@ -56,7 +58,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
        <span class="keyword">let</span> <span class="variable declaration">x</span> = <span class="numeric_literal">92</span>;
        <span class="variable mutable">vec</span>.<span class="unresolved_reference">push</span>(<span class="struct">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="numeric_literal">1</span> });
    }
-    <span class="keyword unsafe">unsafe</span> { <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>); }
+    <span class="keyword unsafe">unsafe</span> {
+        <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>);
+        <span class="static mutable">STATIC_MUT</span> = <span class="numeric_literal">1</span>;
+    }
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 6658c7bb2..d53a39f57 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -167,6 +167,19 @@ pub(crate) fn highlight(
                        binding_hash: None,
                    });
                }
+                if let Some(name) = mc.is_macro_rules() {
+                    if let Some((highlight, binding_hash)) = highlight_element(
+                        &sema,
+                        &mut bindings_shadow_count,
+                        name.syntax().clone().into(),
+                    ) {
+                        stack.add(HighlightedRange {
+                            range: name.syntax().text_range(),
+                            highlight,
+                            binding_hash,
+                        });
+                    }
+                }
                continue;
            }
            WalkEvent::Leave(Some(mc)) => {
@@ -431,10 +444,16 @@ fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
            hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
            hir::ModuleDef::Const(_) => HighlightTag::Constant,
-            hir::ModuleDef::Static(_) => HighlightTag::Static,
            hir::ModuleDef::Trait(_) => HighlightTag::Trait,
            hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
            hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
+            hir::ModuleDef::Static(s) => {
+                let mut h = Highlight::new(HighlightTag::Static);
+                if s.is_mut(db) {
+                    h |= HighlightModifier::Mutable;
+                }
+                return h;
+            }
        },
        Definition::SelfType(_) => HighlightTag::SelfType,
        Definition::TypeParam(_) => HighlightTag::TypeParam,
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index d2926ba78..13894869c 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -17,6 +17,8 @@ struct Foo {
    pub y: i32,
 }
+static mut STATIC_MUT: i32 = 0;
 fn foo<'a, T>() -> T {
    foo::<'a, i32>()
 }
@@ -40,7 +42,10 @@ fn main() {
        let x = 92;
        vec.push(Foo { x, y: 1 });
    }
-    unsafe { vec.set_len(0); }
+    unsafe {
+        vec.set_len(0);
+        STATIC_MUT = 1;
+    }
    let mut x = 42;
    let y = &mut x;
diff --git a/crates/ra_proc_macro_srv/Cargo.toml b/crates/ra_proc_macro_srv/Cargo.toml
index 886e14870..bb3003278 100644
--- a/crates/ra_proc_macro_srv/Cargo.toml
+++ b/crates/ra_proc_macro_srv/Cargo.toml
@@ -18,7 +18,7 @@ memmap = "0.7"
 test_utils = { path = "../test_utils" }
 [dev-dependencies]
-cargo_metadata = "0.9.1"
+cargo_metadata = "0.10.0"
 difference = "2.0.0"
 # used as proc macro test target
-serde_derive = "=1.0.106"
+serde_derive = "1.0.106"
diff --git a/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
index 6776f5231..bc010cfe9 100644
--- a/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
+++ b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
@@ -23,23 +23,12 @@ SUBTREE $
    SUBTREE [] 4294967295
      IDENT   allow 4294967295
      SUBTREE () 4294967295
-        IDENT   unknown_lints 4294967295
-    PUNCH   # [alone] 4294967295
-    SUBTREE [] 4294967295
-      IDENT   cfg_attr 4294967295
-      SUBTREE () 4294967295
-        IDENT   feature 4294967295
-        PUNCH   = [alone] 4294967295
-        LITERAL "cargo-clippy" 0
-        PUNCH   , [alone] 4294967295
-        IDENT   allow 4294967295
-        SUBTREE () 4294967295
-          IDENT   useless_attribute 4294967295
-    PUNCH   # [alone] 4294967295
-    SUBTREE [] 4294967295
-      IDENT   allow 4294967295
-      SUBTREE () 4294967295
        IDENT   rust_2018_idioms 4294967295
+        PUNCH   , [alone] 4294967295
+        IDENT   clippy 4294967295
+        PUNCH   : [joint] 4294967295
+        PUNCH   : [alone] 4294967295
+        IDENT   useless_attribute 4294967295
    IDENT   extern 4294967295
    IDENT   crate 4294967295
    IDENT   serde 4294967295
diff --git a/crates/ra_proc_macro_srv/src/tests/mod.rs b/crates/ra_proc_macro_srv/src/tests/mod.rs
index 9cf58511c..82cefbb29 100644
--- a/crates/ra_proc_macro_srv/src/tests/mod.rs
+++ b/crates/ra_proc_macro_srv/src/tests/mod.rs
@@ -10,7 +10,7 @@ fn test_derive_serialize_proc_macro() {
    assert_expand(
        "serde_derive",
        "Serialize",
-        "1.0.106",
+        "1.0",
        r##"struct Foo {}"##,
        include_str!("fixtures/test_serialize_proc_macro.txt"),
    );
@@ -21,7 +21,7 @@ fn test_derive_serialize_proc_macro_failed() {
    assert_expand(
        "serde_derive",
        "Serialize",
-        "1.0.106",
+        "1.0",
        r##"
    struct {}
 "##,
@@ -37,7 +37,7 @@ SUBTREE $
 #[test]
 fn test_derive_proc_macro_list() {
-    let res = list("serde_derive", "1.0.106").join("\n");
+    let res = list("serde_derive", "1.0").join("\n");
    assert_eq_text!(
        &res,
diff --git a/crates/ra_proc_macro_srv/src/tests/utils.rs b/crates/ra_proc_macro_srv/src/tests/utils.rs
index 646a427c5..84348b5de 100644
--- a/crates/ra_proc_macro_srv/src/tests/utils.rs
+++ b/crates/ra_proc_macro_srv/src/tests/utils.rs
@@ -8,7 +8,7 @@ use std::str::FromStr;
 use test_utils::assert_eq_text;
 mod fixtures {
-    use cargo_metadata::{parse_messages, Message};
+    use cargo_metadata::Message;
    use std::process::Command;
    // Use current project metadata to get the proc-macro dylib path
@@ -19,7 +19,7 @@ mod fixtures {
            .unwrap()
            .stdout;
-        for message in parse_messages(command.as_slice()) {
+        for message in Message::parse_stream(command.as_slice()) {
            match message.unwrap() {
                Message::CompilerArtifact(artifact) => {
                    if artifact.target.kind.contains(&"proc-macro".to_string()) {
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index a32a5daab..e4a60f4c0 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 log = "0.4.8"
 rustc-hash = "1.1.0"
-cargo_metadata = "0.9.1"
+cargo_metadata = "0.10.0"
 ra_arena = { path = "../ra_arena" }
 ra_cfg = { path = "../ra_cfg" }
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 082af4f96..a306ce95f 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -161,7 +161,7 @@ impl CargoWorkspace {
            meta.current_dir(parent);
        }
        if let Some(target) = cargo_features.target.as_ref() {
-            meta.other_options(&[String::from("--filter-platform"), target.clone()]);
+            meta.other_options(vec![String::from("--filter-platform"), target.clone()]);
        }
        let meta = meta.exec().with_context(|| {
            format!("Failed to run `cargo metadata --manifest-path {}`", cargo_toml.display())
@@ -304,19 +304,13 @@ pub fn load_extern_resources(
    let mut res = ExternResources::default();
-    for message in cargo_metadata::parse_messages(output.stdout.as_slice()) {
+    for message in cargo_metadata::Message::parse_stream(output.stdout.as_slice()) {
        if let Ok(message) = message {
            match message {
                Message::BuildScriptExecuted(BuildScript { package_id, out_dir, cfgs, .. }) => {
                    res.out_dirs.insert(package_id.clone(), out_dir);
-                    res.cfgs.insert(
+                    res.cfgs.insert(package_id, cfgs);
-                        package_id,
-                        // FIXME: Current `cargo_metadata` uses `PathBuf` instead of `String`,
-                        // change when https://github.com/oli-obk/cargo_metadata/pulls/112 reaches crates.io
-                        cfgs.iter().filter_map(|c| c.to_str().map(|s| s.to_owned())).collect(),
-                    );
                }
                Message::CompilerArtifact(message) => {
                    if message.target.kind.contains(&"proc-macro".to_string()) {
                        let package_id = message.package_id;
@@ -329,6 +323,8 @@ pub fn load_extern_resources(
                }
                Message::CompilerMessage(_) => (),
                Message::Unknown => (),
+                Message::BuildFinished(_) => {}
+                Message::TextLine(_) => {}
            }
        }
    }
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 3e6dd6061..24a1e1d91 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -453,11 +453,7 @@ impl IndentLevel {
        IndentLevel(0)
    }
-    pub fn increase_indent<N: AstNode>(self, node: N) -> N {
+    fn increase_indent(self, node: SyntaxNode) -> SyntaxNode {
-        N::cast(self._increase_indent(node.syntax().clone())).unwrap()
-    }
-    fn _increase_indent(self, node: SyntaxNode) -> SyntaxNode {
        let mut rewriter = SyntaxRewriter::default();
        node.descendants_with_tokens()
            .filter_map(|el| el.into_token())
@@ -478,11 +474,7 @@ impl IndentLevel {
        rewriter.rewrite(&node)
    }
-    pub fn decrease_indent<N: AstNode>(self, node: N) -> N {
+    fn decrease_indent(self, node: SyntaxNode) -> SyntaxNode {
-        N::cast(self._decrease_indent(node.syntax().clone())).unwrap()
-    }
-    fn _decrease_indent(self, node: SyntaxNode) -> SyntaxNode {
        let mut rewriter = SyntaxRewriter::default();
        node.descendants_with_tokens()
            .filter_map(|el| el.into_token())
@@ -521,7 +513,7 @@ fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
    iter::successors(Some(token), |token| token.prev_token())
 }
-pub trait AstNodeEdit: AstNode + Sized {
+pub trait AstNodeEdit: AstNode + Clone + Sized {
    #[must_use]
    fn insert_children(
        &self,
@@ -558,9 +550,17 @@ pub trait AstNodeEdit: AstNode + Sized {
        }
        rewriter.rewrite_ast(self)
    }
+    #[must_use]
+    fn indent(&self, indent: IndentLevel) -> Self {
+        Self::cast(indent.increase_indent(self.syntax().clone())).unwrap()
+    }
+    #[must_use]
+    fn dedent(&self, indent: IndentLevel) -> Self {
+        Self::cast(indent.decrease_indent(self.syntax().clone())).unwrap()
+    }
 }
-impl<N: AstNode> AstNodeEdit for N {}
+impl<N: AstNode + Clone> AstNodeEdit for N {}
 fn single_node(element: impl Into<SyntaxElement>) -> RangeInclusive<SyntaxElement> {
    let element = element.into();
@@ -580,7 +580,7 @@ fn test_increase_indent() {
    _ => (),
 }"
    );
-    let indented = IndentLevel(2).increase_indent(arm_list);
+    let indented = arm_list.indent(IndentLevel(2));
    assert_eq!(
        indented.syntax().to_string(),
        "{
diff --git a/crates/ra_text_edit/src/lib.rs b/crates/ra_text_edit/src/lib.rs
index 3409713ff..37f77cc47 100644
--- a/crates/ra_text_edit/src/lib.rs
+++ b/crates/ra_text_edit/src/lib.rs
@@ -75,6 +75,7 @@ impl TextEdit {
        self.indels.is_empty()
    }
+    // FXME: impl IntoIter instead
    pub fn as_indels(&self) -> &[Indel] {
        &self.indels
    }
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
deleted file mode 100644
index f64c90b5b..000000000
--- a/crates/rust-analyzer/src/conv.rs
+++ /dev/null
@@ -1,726 +0,0 @@
-//! Convenience module responsible for translating between rust-analyzer's types
-//! and LSP types.
-use lsp_types::{
-    self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
-    Location, LocationLink, MarkupContent, MarkupKind, ParameterInformation, ParameterLabel,
-    Position, Range, RenameFile, ResourceOp, SemanticTokenModifier, SemanticTokenType,
-    SignatureInformation, SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
-    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
-};
-use ra_ide::{
-    translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
-    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag,
-    InlayHint, InlayKind, InsertTextFormat, LineCol, LineIndex, NavigationTarget, RangeInfo,
-    ReferenceAccess, Severity, SourceChange, SourceFileEdit,
-};
-use ra_syntax::{SyntaxKind, TextRange, TextSize};
-use ra_text_edit::{Indel, TextEdit};
-use ra_vfs::LineEndings;
-use crate::{
-    req,
-    semantic_tokens::{self, ModifierSet, CONSTANT, CONTROL_FLOW, MUTABLE, UNSAFE},
-    world::WorldSnapshot,
-    Result,
-};
-use semantic_tokens::{
-    ATTRIBUTE, BUILTIN_TYPE, ENUM_MEMBER, FORMAT_SPECIFIER, LIFETIME, TYPE_ALIAS, UNION,
-    UNRESOLVED_REFERENCE,
-};
-pub trait Conv {
-    type Output;
-    fn conv(self) -> Self::Output;
-}
-pub trait ConvWith<CTX> {
-    type Output;
-    fn conv_with(self, ctx: CTX) -> Self::Output;
-}
-pub trait TryConvWith<CTX> {
-    type Output;
-    fn try_conv_with(self, ctx: CTX) -> Result<Self::Output>;
-}
-impl Conv for SyntaxKind {
-    type Output = SymbolKind;
-    fn conv(self) -> <Self as Conv>::Output {
-        match self {
-            SyntaxKind::FN_DEF => SymbolKind::Function,
-            SyntaxKind::STRUCT_DEF => SymbolKind::Struct,
-            SyntaxKind::ENUM_DEF => SymbolKind::Enum,
-            SyntaxKind::ENUM_VARIANT => SymbolKind::EnumMember,
-            SyntaxKind::TRAIT_DEF => SymbolKind::Interface,
-            SyntaxKind::MACRO_CALL => SymbolKind::Function,
-            SyntaxKind::MODULE => SymbolKind::Module,
-            SyntaxKind::TYPE_ALIAS_DEF => SymbolKind::TypeParameter,
-            SyntaxKind::RECORD_FIELD_DEF => SymbolKind::Field,
-            SyntaxKind::STATIC_DEF => SymbolKind::Constant,
-            SyntaxKind::CONST_DEF => SymbolKind::Constant,
-            SyntaxKind::IMPL_DEF => SymbolKind::Object,
-            _ => SymbolKind::Variable,
-        }
-    }
-}
-impl Conv for ReferenceAccess {
-    type Output = ::lsp_types::DocumentHighlightKind;
-    fn conv(self) -> Self::Output {
-        use lsp_types::DocumentHighlightKind;
-        match self {
-            ReferenceAccess::Read => DocumentHighlightKind::Read,
-            ReferenceAccess::Write => DocumentHighlightKind::Write,
-        }
-    }
-}
-impl Conv for CompletionItemKind {
-    type Output = ::lsp_types::CompletionItemKind;
-    fn conv(self) -> <Self as Conv>::Output {
-        use lsp_types::CompletionItemKind::*;
-        match self {
-            CompletionItemKind::Keyword => Keyword,
-            CompletionItemKind::Snippet => Snippet,
-            CompletionItemKind::Module => Module,
-            CompletionItemKind::Function => Function,
-            CompletionItemKind::Struct => Struct,
-            CompletionItemKind::Enum => Enum,
-            CompletionItemKind::EnumVariant => EnumMember,
-            CompletionItemKind::BuiltinType => Struct,
-            CompletionItemKind::Binding => Variable,
-            CompletionItemKind::Field => Field,
-            CompletionItemKind::Trait => Interface,
-            CompletionItemKind::TypeAlias => Struct,
-            CompletionItemKind::Const => Constant,
-            CompletionItemKind::Static => Value,
-            CompletionItemKind::Method => Method,
-            CompletionItemKind::TypeParam => TypeParameter,
-            CompletionItemKind::Macro => Method,
-            CompletionItemKind::Attribute => EnumMember,
-        }
-    }
-}
-impl Conv for Severity {
-    type Output = DiagnosticSeverity;
-    fn conv(self) -> DiagnosticSeverity {
-        match self {
-            Severity::Error => DiagnosticSeverity::Error,
-            Severity::WeakWarning => DiagnosticSeverity::Hint,
-        }
-    }
-}
-impl ConvWith<(&LineIndex, LineEndings)> for CompletionItem {
-    type Output = ::lsp_types::CompletionItem;
-    fn conv_with(self, ctx: (&LineIndex, LineEndings)) -> ::lsp_types::CompletionItem {
-        let mut additional_text_edits = Vec::new();
-        let mut text_edit = None;
-        // LSP does not allow arbitrary edits in completion, so we have to do a
-        // non-trivial mapping here.
-        for indel in self.text_edit().as_indels() {
-            if indel.delete.contains_range(self.source_range()) {
-                text_edit = Some(if indel.delete == self.source_range() {
-                    indel.conv_with((ctx.0, ctx.1))
-                } else {
-                    assert!(self.source_range().end() == indel.delete.end());
-                    let range1 = TextRange::new(indel.delete.start(), self.source_range().start());
-                    let range2 = self.source_range();
-                    let edit1 = Indel::replace(range1, String::new());
-                    let edit2 = Indel::replace(range2, indel.insert.clone());
-                    additional_text_edits.push(edit1.conv_with((ctx.0, ctx.1)));
-                    edit2.conv_with((ctx.0, ctx.1))
-                })
-            } else {
-                assert!(self.source_range().intersect(indel.delete).is_none());
-                additional_text_edits.push(indel.conv_with((ctx.0, ctx.1)));
-            }
-        }
-        let text_edit = text_edit.unwrap();
-        let mut res = lsp_types::CompletionItem {
-            label: self.label().to_string(),
-            detail: self.detail().map(|it| it.to_string()),
-            filter_text: Some(self.lookup().to_string()),
-            kind: self.kind().map(|it| it.conv()),
-            text_edit: Some(text_edit.into()),
-            additional_text_edits: Some(additional_text_edits),
-            documentation: self.documentation().map(|it| it.conv()),
-            deprecated: Some(self.deprecated()),
-            command: if self.trigger_call_info() {
-                let cmd = lsp_types::Command {
-                    title: "triggerParameterHints".into(),
-                    command: "editor.action.triggerParameterHints".into(),
-                    arguments: None,
-                };
-                Some(cmd)
-            } else {
-                None
-            },
-            ..Default::default()
-        };
-        if self.score().is_some() {
-            res.preselect = Some(true)
-        }
-        if self.deprecated() {
-            res.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated])
-        }
-        res.insert_text_format = Some(match self.insert_text_format() {
-            InsertTextFormat::Snippet => lsp_types::InsertTextFormat::Snippet,
-            InsertTextFormat::PlainText => lsp_types::InsertTextFormat::PlainText,
-        });
-        res
-    }
-}
-impl ConvWith<&LineIndex> for Position {
-    type Output = TextSize;
-    fn conv_with(self, line_index: &LineIndex) -> TextSize {
-        let line_col = LineCol { line: self.line as u32, col_utf16: self.character as u32 };
-        line_index.offset(line_col)
-    }
-}
-impl ConvWith<&LineIndex> for TextSize {
-    type Output = Position;
-    fn conv_with(self, line_index: &LineIndex) -> Position {
-        let line_col = line_index.line_col(self);
-        Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16))
-    }
-}
-impl ConvWith<&LineIndex> for TextRange {
-    type Output = Range;
-    fn conv_with(self, line_index: &LineIndex) -> Range {
-        Range::new(self.start().conv_with(line_index), self.end().conv_with(line_index))
-    }
-}
-impl ConvWith<&LineIndex> for Range {
-    type Output = TextRange;
-    fn conv_with(self, line_index: &LineIndex) -> TextRange {
-        TextRange::new(self.start.conv_with(line_index), self.end.conv_with(line_index))
-    }
-}
-impl Conv for ra_ide::Documentation {
-    type Output = lsp_types::Documentation;
-    fn conv(self) -> Documentation {
-        Documentation::MarkupContent(MarkupContent {
-            kind: MarkupKind::Markdown,
-            value: crate::markdown::format_docs(self.as_str()),
-        })
-    }
-}
-impl ConvWith<bool> for ra_ide::FunctionSignature {
-    type Output = lsp_types::SignatureInformation;
-    fn conv_with(self, concise: bool) -> Self::Output {
-        let (label, documentation, params) = if concise {
-            let mut params = self.parameters;
-            if self.has_self_param {
-                params.remove(0);
-            }
-            (params.join(", "), None, params)
-        } else {
-            (self.to_string(), self.doc.map(|it| it.conv()), self.parameters)
-        };
-        let parameters: Vec<ParameterInformation> = params
-            .into_iter()
-            .map(|param| ParameterInformation {
-                label: ParameterLabel::Simple(param),
-                documentation: None,
-            })
-            .collect();
-        SignatureInformation { label, documentation, parameters: Some(parameters) }
-    }
-}
-impl ConvWith<(&LineIndex, LineEndings)> for TextEdit {
-    type Output = Vec<lsp_types::TextEdit>;
-    fn conv_with(self, ctx: (&LineIndex, LineEndings)) -> Vec<lsp_types::TextEdit> {
-        self.as_indels().iter().map_conv_with(ctx).collect()
-    }
-}
-impl ConvWith<(&LineIndex, LineEndings)> for &Indel {
-    type Output = lsp_types::TextEdit;
-    fn conv_with(
-        self,
-        (line_index, line_endings): (&LineIndex, LineEndings),
-    ) -> lsp_types::TextEdit {
-        let mut new_text = self.insert.clone();
-        if line_endings == LineEndings::Dos {
-            new_text = new_text.replace('\n', "\r\n");
-        }
-        lsp_types::TextEdit { range: self.delete.conv_with(line_index), new_text }
-    }
-}
-pub(crate) struct FoldConvCtx<'a> {
-    pub(crate) text: &'a str,
-    pub(crate) line_index: &'a LineIndex,
-    pub(crate) line_folding_only: bool,
-}
-impl ConvWith<&FoldConvCtx<'_>> for Fold {
-    type Output = lsp_types::FoldingRange;
-    fn conv_with(self, ctx: &FoldConvCtx) -> lsp_types::FoldingRange {
-        let kind = match self.kind {
-            FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment),
-            FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports),
-            FoldKind::Mods => None,
-            FoldKind::Block => None,
-        };
-        let range = self.range.conv_with(&ctx.line_index);
-        if ctx.line_folding_only {
-            // Clients with line_folding_only == true (such as VSCode) will fold the whole end line
-            // even if it contains text not in the folding range. To prevent that we exclude
-            // range.end.line from the folding region if there is more text after range.end
-            // on the same line.
-            let has_more_text_on_end_line = ctx.text
-                [TextRange::new(self.range.end(), TextSize::of(ctx.text))]
-            .chars()
-            .take_while(|it| *it != '\n')
-            .any(|it| !it.is_whitespace());
-            let end_line = if has_more_text_on_end_line {
-                range.end.line.saturating_sub(1)
-            } else {
-                range.end.line
-            };
-            lsp_types::FoldingRange {
-                start_line: range.start.line,
-                start_character: None,
-                end_line,
-                end_character: None,
-                kind,
-            }
-        } else {
-            lsp_types::FoldingRange {
-                start_line: range.start.line,
-                start_character: Some(range.start.character),
-                end_line: range.end.line,
-                end_character: Some(range.end.character),
-                kind,
-            }
-        }
-    }
-}
-impl ConvWith<&LineIndex> for InlayHint {
-    type Output = req::InlayHint;
-    fn conv_with(self, line_index: &LineIndex) -> Self::Output {
-        req::InlayHint {
-            label: self.label.to_string(),
-            range: self.range.conv_with(line_index),
-            kind: match self.kind {
-                InlayKind::ParameterHint => req::InlayKind::ParameterHint,
-                InlayKind::TypeHint => req::InlayKind::TypeHint,
-                InlayKind::ChainingHint => req::InlayKind::ChainingHint,
-            },
-        }
-    }
-}
-impl Conv for Highlight {
-    type Output = (u32, u32);
-    fn conv(self) -> Self::Output {
-        let mut mods = ModifierSet::default();
-        let type_ = match self.tag {
-            HighlightTag::Struct => SemanticTokenType::STRUCT,
-            HighlightTag::Enum => SemanticTokenType::ENUM,
-            HighlightTag::Union => UNION,
-            HighlightTag::TypeAlias => TYPE_ALIAS,
-            HighlightTag::Trait => SemanticTokenType::INTERFACE,
-            HighlightTag::BuiltinType => BUILTIN_TYPE,
-            HighlightTag::SelfType => SemanticTokenType::TYPE,
-            HighlightTag::Field => SemanticTokenType::MEMBER,
-            HighlightTag::Function => SemanticTokenType::FUNCTION,
-            HighlightTag::Module => SemanticTokenType::NAMESPACE,
-            HighlightTag::Constant => {
-                mods |= CONSTANT;
-                mods |= SemanticTokenModifier::STATIC;
-                SemanticTokenType::VARIABLE
-            }
-            HighlightTag::Static => {
-                mods |= SemanticTokenModifier::STATIC;
-                SemanticTokenType::VARIABLE
-            }
-            HighlightTag::EnumVariant => ENUM_MEMBER,
-            HighlightTag::Macro => SemanticTokenType::MACRO,
-            HighlightTag::Local => SemanticTokenType::VARIABLE,
-            HighlightTag::TypeParam => SemanticTokenType::TYPE_PARAMETER,
-            HighlightTag::Lifetime => LIFETIME,
-            HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => SemanticTokenType::NUMBER,
-            HighlightTag::CharLiteral | HighlightTag::StringLiteral => SemanticTokenType::STRING,
-            HighlightTag::Comment => SemanticTokenType::COMMENT,
-            HighlightTag::Attribute => ATTRIBUTE,
-            HighlightTag::Keyword => SemanticTokenType::KEYWORD,
-            HighlightTag::UnresolvedReference => UNRESOLVED_REFERENCE,
-            HighlightTag::FormatSpecifier => FORMAT_SPECIFIER,
-        };
-        for modifier in self.modifiers.iter() {
-            let modifier = match modifier {
-                HighlightModifier::Definition => SemanticTokenModifier::DECLARATION,
-                HighlightModifier::ControlFlow => CONTROL_FLOW,
-                HighlightModifier::Mutable => MUTABLE,
-                HighlightModifier::Unsafe => UNSAFE,
-            };
-            mods |= modifier;
-        }
-        (semantic_tokens::type_index(type_), mods.0)
-    }
-}
-impl<T: ConvWith<CTX>, CTX> ConvWith<CTX> for Option<T> {
-    type Output = Option<T::Output>;
-    fn conv_with(self, ctx: CTX) -> Self::Output {
-        self.map(|x| ConvWith::conv_with(x, ctx))
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &Url {
-    type Output = FileId;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
-        world.uri_to_file_id(self)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for FileId {
-    type Output = Url;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<Url> {
-        world.file_id_to_uri(self)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &TextDocumentItem {
-    type Output = FileId;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
-        self.uri.try_conv_with(world)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &VersionedTextDocumentIdentifier {
-    type Output = FileId;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
-        self.uri.try_conv_with(world)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &TextDocumentIdentifier {
-    type Output = FileId;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
-        world.uri_to_file_id(&self.uri)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &TextDocumentPositionParams {
-    type Output = FilePosition;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FilePosition> {
-        let file_id = self.text_document.try_conv_with(world)?;
-        let line_index = world.analysis().file_line_index(file_id)?;
-        let offset = self.position.conv_with(&line_index);
-        Ok(FilePosition { file_id, offset })
-    }
-}
-impl TryConvWith<&WorldSnapshot> for (&TextDocumentIdentifier, Range) {
-    type Output = FileRange;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileRange> {
-        let file_id = self.0.try_conv_with(world)?;
-        let line_index = world.analysis().file_line_index(file_id)?;
-        let range = self.1.conv_with(&line_index);
-        Ok(FileRange { file_id, range })
-    }
-}
-impl<T: TryConvWith<CTX>, CTX: Copy> TryConvWith<CTX> for Vec<T> {
-    type Output = Vec<<T as TryConvWith<CTX>>::Output>;
-    fn try_conv_with(self, ctx: CTX) -> Result<Self::Output> {
-        let mut res = Vec::with_capacity(self.len());
-        for item in self {
-            res.push(item.try_conv_with(ctx)?);
-        }
-        Ok(res)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for SourceChange {
-    type Output = req::SourceChange;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<req::SourceChange> {
-        let cursor_position = match self.cursor_position {
-            None => None,
-            Some(pos) => {
-                let line_index = world.analysis().file_line_index(pos.file_id)?;
-                let edit = self
-                    .source_file_edits
-                    .iter()
-                    .find(|it| it.file_id == pos.file_id)
-                    .map(|it| &it.edit);
-                let line_col = match edit {
-                    Some(edit) => translate_offset_with_edit(&*line_index, pos.offset, edit),
-                    None => line_index.line_col(pos.offset),
-                };
-                let position =
-                    Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16));
-                Some(TextDocumentPositionParams {
-                    text_document: TextDocumentIdentifier::new(pos.file_id.try_conv_with(world)?),
-                    position,
-                })
-            }
-        };
-        let mut document_changes: Vec<DocumentChangeOperation> = Vec::new();
-        for resource_op in self.file_system_edits.try_conv_with(world)? {
-            document_changes.push(DocumentChangeOperation::Op(resource_op));
-        }
-        for text_document_edit in self.source_file_edits.try_conv_with(world)? {
-            document_changes.push(DocumentChangeOperation::Edit(text_document_edit));
-        }
-        let workspace_edit = WorkspaceEdit {
-            changes: None,
-            document_changes: Some(DocumentChanges::Operations(document_changes)),
-        };
-        Ok(req::SourceChange { label: self.label, workspace_edit, cursor_position })
-    }
-}
-impl TryConvWith<&WorldSnapshot> for SourceFileEdit {
-    type Output = TextDocumentEdit;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<TextDocumentEdit> {
-        let text_document = VersionedTextDocumentIdentifier {
-            uri: self.file_id.try_conv_with(world)?,
-            version: None,
-        };
-        let line_index = world.analysis().file_line_index(self.file_id)?;
-        let line_endings = world.file_line_endings(self.file_id);
-        let edits =
-            self.edit.as_indels().iter().map_conv_with((&line_index, line_endings)).collect();
-        Ok(TextDocumentEdit { text_document, edits })
-    }
-}
-impl TryConvWith<&WorldSnapshot> for FileSystemEdit {
-    type Output = ResourceOp;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<ResourceOp> {
-        let res = match self {
-            FileSystemEdit::CreateFile { source_root, path } => {
-                let uri = world.path_to_uri(source_root, &path)?;
-                ResourceOp::Create(CreateFile { uri, options: None })
-            }
-            FileSystemEdit::MoveFile { src, dst_source_root, dst_path } => {
-                let old_uri = world.file_id_to_uri(src)?;
-                let new_uri = world.path_to_uri(dst_source_root, &dst_path)?;
-                ResourceOp::Rename(RenameFile { old_uri, new_uri, options: None })
-            }
-        };
-        Ok(res)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for &NavigationTarget {
-    type Output = Location;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<Location> {
-        let line_index = world.analysis().file_line_index(self.file_id())?;
-        let range = self.range();
-        to_location(self.file_id(), range, &world, &line_index)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<NavigationTarget>) {
-    type Output = LocationLink;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<LocationLink> {
-        let (src_file_id, target) = self;
-        let target_uri = target.info.file_id().try_conv_with(world)?;
-        let src_line_index = world.analysis().file_line_index(src_file_id)?;
-        let tgt_line_index = world.analysis().file_line_index(target.info.file_id())?;
-        let target_range = target.info.full_range().conv_with(&tgt_line_index);
-        let target_selection_range = target
-            .info
-            .focus_range()
-            .map(|it| it.conv_with(&tgt_line_index))
-            .unwrap_or(target_range);
-        let res = LocationLink {
-            origin_selection_range: Some(target.range.conv_with(&src_line_index)),
-            target_uri,
-            target_range,
-            target_selection_range,
-        };
-        Ok(res)
-    }
-}
-impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<Vec<NavigationTarget>>) {
-    type Output = req::GotoDefinitionResponse;
-    fn try_conv_with(self, world: &WorldSnapshot) -> Result<req::GotoTypeDefinitionResponse> {
-        let (file_id, RangeInfo { range, info: navs }) = self;
-        let links = navs
-            .into_iter()
-            .map(|nav| (file_id, RangeInfo::new(range, nav)))
-            .try_conv_with_to_vec(world)?;
-        if world.config.client_caps.location_link {
-            Ok(links.into())
-        } else {
-            let locations: Vec<Location> = links
-                .into_iter()
-                .map(|link| Location { uri: link.target_uri, range: link.target_selection_range })
-                .collect();
-            Ok(locations.into())
-        }
-    }
-}
-pub fn to_call_hierarchy_item(
-    file_id: FileId,
-    range: TextRange,
-    world: &WorldSnapshot,
-    line_index: &LineIndex,
-    nav: NavigationTarget,
-) -> Result<lsp_types::CallHierarchyItem> {
-    Ok(lsp_types::CallHierarchyItem {
-        name: nav.name().to_string(),
-        kind: nav.kind().conv(),
-        tags: None,
-        detail: nav.description().map(|it| it.to_string()),
-        uri: file_id.try_conv_with(&world)?,
-        range: nav.range().conv_with(&line_index),
-        selection_range: range.conv_with(&line_index),
-    })
-}
-pub fn to_location(
-    file_id: FileId,
-    range: TextRange,
-    world: &WorldSnapshot,
-    line_index: &LineIndex,
-) -> Result<Location> {
-    let url = file_id.try_conv_with(world)?;
-    let loc = Location::new(url, range.conv_with(line_index));
-    Ok(loc)
-}
-pub trait MapConvWith<CTX>: Sized {
-    type Output;
-    fn map_conv_with(self, ctx: CTX) -> ConvWithIter<Self, CTX> {
-        ConvWithIter { iter: self, ctx }
-    }
-}
-impl<CTX, I> MapConvWith<CTX> for I
-where
-    I: Iterator,
-    I::Item: ConvWith<CTX>,
-{
-    type Output = <I::Item as ConvWith<CTX>>::Output;
-}
-pub struct ConvWithIter<I, CTX> {
-    iter: I,
-    ctx: CTX,
-}
-impl<I, CTX> Iterator for ConvWithIter<I, CTX>
-where
-    I: Iterator,
-    I::Item: ConvWith<CTX>,
-    CTX: Copy,
-{
-    type Item = <I::Item as ConvWith<CTX>>::Output;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|item| item.conv_with(self.ctx))
-    }
-}
-pub trait TryConvWithToVec<CTX>: Sized {
-    type Output;
-    fn try_conv_with_to_vec(self, ctx: CTX) -> Result<Vec<Self::Output>>;
-}
-impl<I, CTX> TryConvWithToVec<CTX> for I
-where
-    I: Iterator,
-    I::Item: TryConvWith<CTX>,
-    CTX: Copy,
-{
-    type Output = <I::Item as TryConvWith<CTX>>::Output;
-    fn try_conv_with_to_vec(self, ctx: CTX) -> Result<Vec<Self::Output>> {
-        self.map(|it| it.try_conv_with(ctx)).collect()
-    }
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test_utils::extract_ranges;
-    #[test]
-    fn conv_fold_line_folding_only_fixup() {
-        let text = r#"<fold>mod a;
-mod b;
-mod c;</fold>
-fn main() <fold>{
-    if cond <fold>{
-        a::do_a();
-    }</fold> else <fold>{
-        b::do_b();
-    }</fold>
-}</fold>"#;
-        let (ranges, text) = extract_ranges(text, "fold");
-        assert_eq!(ranges.len(), 4);
-        let folds = vec![
-            Fold { range: ranges[0], kind: FoldKind::Mods },
-            Fold { range: ranges[1], kind: FoldKind::Block },
-            Fold { range: ranges[2], kind: FoldKind::Block },
-            Fold { range: ranges[3], kind: FoldKind::Block },
-        ];
-        let line_index = LineIndex::new(&text);
-        let ctx = FoldConvCtx { text: &text, line_index: &line_index, line_folding_only: true };
-        let converted: Vec<_> = folds.into_iter().map_conv_with(&ctx).collect();
-        let expected_lines = [(0, 2), (4, 10), (5, 6), (7, 9)];
-        assert_eq!(converted.len(), expected_lines.len());
-        for (folding_range, (start_line, end_line)) in converted.iter().zip(expected_lines.iter()) {
-            assert_eq!(folding_range.start_line, *start_line);
-            assert_eq!(folding_range.start_character, None);
-            assert_eq!(folding_range.end_line, *end_line);
-            assert_eq!(folding_range.end_character, None);
-        }
-    }
-}
diff --git a/crates/rust-analyzer/src/from_proto.rs b/crates/rust-analyzer/src/from_proto.rs
new file mode 100644
index 000000000..4bb16a496
--- /dev/null
+++ b/crates/rust-analyzer/src/from_proto.rs
@@ -0,0 +1,42 @@
+//! Conversion lsp_types types to rust-analyzer specific ones.
+use ra_db::{FileId, FilePosition, FileRange};
+use ra_ide::{LineCol, LineIndex};
+use ra_syntax::{TextRange, TextSize};
+use crate::{world::WorldSnapshot, Result};
+pub(crate) fn offset(line_index: &LineIndex, position: lsp_types::Position) -> TextSize {
+    let line_col = LineCol { line: position.line as u32, col_utf16: position.character as u32 };
+    line_index.offset(line_col)
+}
+pub(crate) fn text_range(line_index: &LineIndex, range: lsp_types::Range) -> TextRange {
+    let start = offset(line_index, range.start);
+    let end = offset(line_index, range.end);
+    TextRange::new(start, end)
+}
+pub(crate) fn file_id(world: &WorldSnapshot, url: &lsp_types::Url) -> Result<FileId> {
+    world.uri_to_file_id(url)
+}
+pub(crate) fn file_position(
+    world: &WorldSnapshot,
+    tdpp: lsp_types::TextDocumentPositionParams,
+) -> Result<FilePosition> {
+    let file_id = file_id(world, &tdpp.text_document.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let offset = offset(&*line_index, tdpp.position);
+    Ok(FilePosition { file_id, offset })
+}
+pub(crate) fn file_range(
+    world: &WorldSnapshot,
+    text_document_identifier: lsp_types::TextDocumentIdentifier,
+    range: lsp_types::Range,
+) -> Result<FileRange> {
+    let file_id = file_id(world, &text_document_identifier.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let range = text_range(&line_index, range);
+    Ok(FileRange { file_id, range })
+}
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 036bf62a7..57d0e9218 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -20,10 +20,11 @@ macro_rules! eprintln {
 mod vfs_glob;
 mod caps;
 mod cargo_target_spec;
-mod conv;
+mod to_proto;
+mod from_proto;
 mod main_loop;
 mod markdown;
-pub mod req;
+pub mod lsp_ext;
 pub mod config;
 mod world;
 mod diagnostics;
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 0dae6bad4..313a8c769 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -1,25 +1,12 @@
-//! Defines `rust-analyzer` specific custom messages.
+//! rust-analyzer extensions to the LSP.
+use std::path::PathBuf;
+use lsp_types::request::Request;
 use lsp_types::{Location, Position, Range, TextDocumentIdentifier};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
-pub use lsp_types::{
-    notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
-    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationItem, ConfigurationParams,
-    DiagnosticTag, DidChangeConfigurationParams, DidChangeWatchedFilesParams,
-    DidChangeWatchedFilesRegistrationOptions, DocumentHighlightParams,
-    DocumentOnTypeFormattingParams, DocumentSymbolParams, DocumentSymbolResponse,
-    FileSystemWatcher, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverParams,
-    InitializeResult, MessageType, PartialResultParams, ProgressParams, ProgressParamsValue,
-    ProgressToken, PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams,
-    SelectionRange, SelectionRangeParams, SemanticTokensParams, SemanticTokensRangeParams,
-    SemanticTokensRangeResult, SemanticTokensResult, ServerCapabilities, ShowMessageParams,
-    SignatureHelp, SignatureHelpParams, SymbolKind, TextDocumentEdit, TextDocumentPositionParams,
-    TextEdit, WorkDoneProgressParams, WorkspaceEdit, WorkspaceSymbolParams,
-};
-use std::path::PathBuf;
 pub enum AnalyzerStatus {}
 impl Request for AnalyzerStatus {
@@ -91,7 +78,7 @@ pub struct FindMatchingBraceParams {
 pub enum ParentModule {}
 impl Request for ParentModule {
-    type Params = TextDocumentPositionParams;
+    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Vec<Location>;
    const METHOD: &'static str = "rust-analyzer/parentModule";
 }
@@ -114,7 +101,7 @@ pub struct JoinLinesParams {
 pub enum OnEnter {}
 impl Request for OnEnter {
-    type Params = TextDocumentPositionParams;
+    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Option<SourceChange>;
    const METHOD: &'static str = "rust-analyzer/onEnter";
 }
@@ -150,8 +137,8 @@ pub struct Runnable {
 #[serde(rename_all = "camelCase")]
 pub struct SourceChange {
    pub label: String,
-    pub workspace_edit: WorkspaceEdit,
+    pub workspace_edit: lsp_types::WorkspaceEdit,
-    pub cursor_position: Option<TextDocumentPositionParams>,
+    pub cursor_position: Option<lsp_types::TextDocumentPositionParams>,
 }
 pub enum InlayHints {}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index a8fa2af08..3f12dd718 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -37,13 +37,12 @@ use threadpool::ThreadPool;
 use crate::{
    config::{Config, FilesWatcher},
-    conv::{ConvWith, TryConvWith},
    diagnostics::DiagnosticTask,
+    from_proto, lsp_ext,
    main_loop::{
        pending_requests::{PendingRequest, PendingRequests},
        subscriptions::Subscriptions,
    },
-    req,
    world::{WorldSnapshot, WorldState},
    Result,
 };
@@ -104,7 +103,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
            if project_roots.is_empty() && config.notifications.cargo_toml_not_found {
                show_message(
-                    req::MessageType::Error,
+                    lsp_types::MessageType::Error,
                    format!(
                        "rust-analyzer failed to discover workspace, no Cargo.toml found, dirs searched: {}",
                        ws_roots.iter().format_with(", ", |it, f| f(&it.display()))
@@ -124,7 +123,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
                    .map_err(|err| {
                        log::error!("failed to load workspace: {:#}", err);
                        show_message(
-                            req::MessageType::Error,
+                            lsp_types::MessageType::Error,
                            format!("rust-analyzer failed to load workspace: {:#}", err),
                            &connection.sender,
                        );
@@ -142,23 +141,25 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
            .collect::<std::result::Result<Vec<_>, _>>()?;
        if let FilesWatcher::Client = config.files.watcher {
-            let registration_options = req::DidChangeWatchedFilesRegistrationOptions {
+            let registration_options = lsp_types::DidChangeWatchedFilesRegistrationOptions {
                watchers: workspaces
                    .iter()
                    .flat_map(ProjectWorkspace::to_roots)
                    .filter(PackageRoot::is_member)
                    .map(|root| format!("{}/**/*.rs", root.path().display()))
-                    .map(|glob_pattern| req::FileSystemWatcher { glob_pattern, kind: None })
+                    .map(|glob_pattern| lsp_types::FileSystemWatcher { glob_pattern, kind: None })
                    .collect(),
            };
-            let registration = req::Registration {
+            let registration = lsp_types::Registration {
                id: "file-watcher".to_string(),
                method: "workspace/didChangeWatchedFiles".to_string(),
                register_options: Some(serde_json::to_value(registration_options).unwrap()),
            };
-            let params = req::RegistrationParams { registrations: vec![registration] };
+            let params = lsp_types::RegistrationParams { registrations: vec![registration] };
-            let request =
+            let request = request_new::<lsp_types::request::RegisterCapability>(
-                request_new::<req::RegisterCapability>(loop_state.next_request_id(), params);
+                loop_state.next_request_id(),
+                params,
+            );
            connection.sender.send(request.into()).unwrap();
        }
@@ -257,14 +258,14 @@ impl fmt::Debug for Event {
        match self {
            Event::Msg(Message::Notification(not)) => {
-                if notification_is::<req::DidOpenTextDocument>(not)
+                if notification_is::<lsp_types::notification::DidOpenTextDocument>(not)
-                    || notification_is::<req::DidChangeTextDocument>(not)
+                    || notification_is::<lsp_types::notification::DidChangeTextDocument>(not)
                {
                    return debug_verbose_not(not, f);
                }
            }
            Event::Task(Task::Notify(not)) => {
-                if notification_is::<req::PublishDiagnostics>(not) {
+                if notification_is::<lsp_types::notification::PublishDiagnostics>(not) {
                    return debug_verbose_not(not, f);
                }
            }
@@ -451,7 +452,7 @@ fn loop_turn(
        log::error!("overly long loop turn: {:?}", loop_duration);
        if env::var("RA_PROFILE").is_ok() {
            show_message(
-                req::MessageType::Error,
+                lsp_types::MessageType::Error,
                format!("overly long loop turn: {:?}", loop_duration),
                &connection.sender,
            );
@@ -501,45 +502,51 @@ fn on_request(
        request_received,
    };
    pool_dispatcher
-        .on_sync::<req::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
+        .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
-        .on_sync::<req::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
+        .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
-        .on_sync::<req::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
+        .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
-        .on_sync::<req::SelectionRangeRequest>(|s, p| {
+        .on_sync::<lsp_types::request::SelectionRangeRequest>(|s, p| {
            handlers::handle_selection_range(s.snapshot(), p)
        })?
-        .on_sync::<req::FindMatchingBrace>(|s, p| {
+        .on_sync::<lsp_ext::FindMatchingBrace>(|s, p| {
            handlers::handle_find_matching_brace(s.snapshot(), p)
        })?
-        .on::<req::AnalyzerStatus>(handlers::handle_analyzer_status)?
+        .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)?
-        .on::<req::SyntaxTree>(handlers::handle_syntax_tree)?
+        .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)?
-        .on::<req::ExpandMacro>(handlers::handle_expand_macro)?
+        .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)?
-        .on::<req::OnTypeFormatting>(handlers::handle_on_type_formatting)?
+        .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)?
-        .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)?
+        .on::<lsp_ext::Runnables>(handlers::handle_runnables)?
-        .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
+        .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
-        .on::<req::GotoDefinition>(handlers::handle_goto_definition)?
+        .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
-        .on::<req::GotoImplementation>(handlers::handle_goto_implementation)?
+        .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
-        .on::<req::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
+        .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
-        .on::<req::ParentModule>(handlers::handle_parent_module)?
+        .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)?
-        .on::<req::Runnables>(handlers::handle_runnables)?
+        .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)?
-        .on::<req::Completion>(handlers::handle_completion)?
+        .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
-        .on::<req::CodeActionRequest>(handlers::handle_code_action)?
+        .on::<lsp_types::request::Completion>(handlers::handle_completion)?
-        .on::<req::CodeLensRequest>(handlers::handle_code_lens)?
+        .on::<lsp_types::request::CodeActionRequest>(handlers::handle_code_action)?
-        .on::<req::CodeLensResolve>(handlers::handle_code_lens_resolve)?
+        .on::<lsp_types::request::CodeLensRequest>(handlers::handle_code_lens)?
-        .on::<req::FoldingRangeRequest>(handlers::handle_folding_range)?
+        .on::<lsp_types::request::CodeLensResolve>(handlers::handle_code_lens_resolve)?
-        .on::<req::SignatureHelpRequest>(handlers::handle_signature_help)?
+        .on::<lsp_types::request::FoldingRangeRequest>(handlers::handle_folding_range)?
-        .on::<req::HoverRequest>(handlers::handle_hover)?
+        .on::<lsp_types::request::SignatureHelpRequest>(handlers::handle_signature_help)?
-        .on::<req::PrepareRenameRequest>(handlers::handle_prepare_rename)?
+        .on::<lsp_types::request::HoverRequest>(handlers::handle_hover)?
-        .on::<req::Rename>(handlers::handle_rename)?
+        .on::<lsp_types::request::PrepareRenameRequest>(handlers::handle_prepare_rename)?
-        .on::<req::References>(handlers::handle_references)?
+        .on::<lsp_types::request::Rename>(handlers::handle_rename)?
-        .on::<req::Formatting>(handlers::handle_formatting)?
+        .on::<lsp_types::request::References>(handlers::handle_references)?
-        .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)?
+        .on::<lsp_types::request::Formatting>(handlers::handle_formatting)?
-        .on::<req::InlayHints>(handlers::handle_inlay_hints)?
+        .on::<lsp_types::request::DocumentHighlightRequest>(handlers::handle_document_highlight)?
-        .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
+        .on::<lsp_types::request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
-        .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
+        .on::<lsp_types::request::CallHierarchyIncomingCalls>(
-        .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
+            handlers::handle_call_hierarchy_incoming,
-        .on::<req::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+        )?
-        .on::<req::SemanticTokensRangeRequest>(handlers::handle_semantic_tokens_range)?
+        .on::<lsp_types::request::CallHierarchyOutgoingCalls>(
-        .on::<req::Ssr>(handlers::handle_ssr)?
+            handlers::handle_call_hierarchy_outgoing,
+        )?
+        .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+        .on::<lsp_types::request::SemanticTokensRangeRequest>(
+            handlers::handle_semantic_tokens_range,
+        )?