40 files changed, 1547 insertions, 1304 deletions

diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 146cc75df..7ced00626 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -209,7 +209,7 @@ struct Test<K, T = u8> {
 }
 
 fn main() {
-    let test<|>: Test<i32, u8> = Test { t: 23, k: 33 };
+    let test<|>: Test<i32> = Test { t: 23, k: 33 };
 }"#,
         );
     }
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'];
-        let expr_to_unwrap = expr_to_unwrap.to_string();
-        let expr_string = expr_to_unwrap.trim_start_matches(pat_start);
-        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);
+        edit.replace(
+            expr.syntax().text_range(),
+            update_expr_string(expr_to_unwrap.to_string(), &[' ', '{', '\n']),
+        );
     })
 }
 
@@ -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 be18c845c..e8e3211fc 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -148,6 +148,26 @@ impl ModuleDef {
             ModuleDef::BuiltinType(_) => None,
         }
     }
+
+    pub fn definition_visibility(&self, db: &dyn HirDatabase) -> Option<Visibility> {
+        let module = match self {
+            ModuleDef::Module(it) => it.parent(db)?,
+            ModuleDef::Function(it) => return Some(it.visibility(db)),
+            ModuleDef::Adt(it) => it.module(db),
+            ModuleDef::EnumVariant(it) => {
+                let parent = it.parent_enum(db);
+                let module = it.module(db);
+                return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)));
+            }
+            ModuleDef::Const(it) => return Some(it.visibility(db)),
+            ModuleDef::Static(it) => it.module(db),
+            ModuleDef::Trait(it) => it.module(db),
+            ModuleDef::TypeAlias(it) => return Some(it.visibility(db)),
+            ModuleDef::BuiltinType(_) => return None,
+        };
+
+        module.visibility_of(db, self)
+    }
 }
 
 pub use hir_def::{
@@ -678,6 +698,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)]
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)]
-    fn static_data(&self, konst: StaticId) -> Arc<ConstData>;
+    #[salsa::invoke(StaticData::static_data_query)]
+    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 f5edaea8c..b9c4d2e89 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -136,6 +136,12 @@ enum DisplayTarget {
     SourceCode { module_id: ModuleId },
 }
 
+impl DisplayTarget {
+    fn is_source_code(&self) -> bool {
+        matches!(self, Self::SourceCode {..})
+    }
+}
+
 #[derive(Debug)]
 pub enum DisplaySourceCodeError {
     PathNotFound,
@@ -303,37 +309,40 @@ impl HirDisplay for ApplicationTy {
 
                 if self.parameters.len() > 0 {
                     let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
-                    let parameters_to_write = if f.omit_verbose_types() {
-                        match self
-                            .ctor
-                            .as_generic_def()
-                            .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) => {
-                                for (i, parameter) in self.parameters.iter().enumerate() {
-                                    match (parameter, default_parameters.get(i)) {
-                                        (&Ty::Unknown, _) | (_, None) => {
-                                            non_default_parameters.push(parameter.clone())
-                                        }
-                                        (_, Some(default_parameter))
-                                            if parameter != default_parameter =>
-                                        {
-                                            non_default_parameters.push(parameter.clone())
+                    let parameters_to_write =
+                        if f.display_target.is_source_code() || f.omit_verbose_types() {
+                            match self
+                                .ctor
+                                .as_generic_def()
+                                .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) => {
+                                    for (i, parameter) in self.parameters.iter().enumerate() {
+                                        match (parameter, default_parameters.get(i)) {
+                                            (&Ty::Unknown, _) | (_, None) => {
+                                                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 {
-                        self.parameters.0.as_ref()
-                    };
-                    write!(f, "<")?;
-                    f.write_joined(parameters_to_write, ", ")?;
-                    write!(f, ">")?;
+                        } else {
+                            self.parameters.0.as_ref()
+                        };
+                    if !parameters_to_write.is_empty() {
+                        write!(f, "<")?;
+                        f.write_joined(parameters_to_write, ", ")?;
+                        write!(f, ">")?;
+                    }
                 }
             }
             TypeCtor::AssociatedType(type_alias) => {
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/display_source_code.rs b/crates/ra_hir_ty/src/tests/display_source_code.rs
index ca1748615..4088b1d22 100644
--- a/crates/ra_hir_ty/src/tests/display_source_code.rs
+++ b/crates/ra_hir_ty/src/tests/display_source_code.rs
@@ -21,3 +21,30 @@ fn bar() {
     );
     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/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/references.rs b/crates/ra_ide/src/references.rs
index 555ccf295..074284b42 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -593,6 +593,31 @@ mod tests {
         check_result(refs, "i BIND_PAT FileId(1) 36..37 Other", &["FileId(1) 51..52 Other Write"]);
     }
 
+    #[test]
+    fn test_find_struct_function_refs_outside_module() {
+        let code = r#"
+        mod foo {
+            pub struct Foo;
+
+            impl Foo {
+                pub fn new<|>() -> Foo {
+                    Foo
+                }
+            }
+        }
+
+        fn main() {
+            let _f = foo::Foo::new();
+        }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "new FN_DEF FileId(1) 87..150 94..97 Other",
+            &["FileId(1) 227..230 StructLiteral"],
+        );
+    }
+
     fn get_all_refs(text: &str) -> ReferenceSearchResult {
         let (analysis, position) = single_file_with_position(text);
         analysis.find_all_refs(position, None).unwrap().unwrap()
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..635fe5cf9 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -33,11 +33,23 @@ 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">trait</span> <span class="trait declaration">Bar</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span>;
+}
+
+<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span> {
+        <span class="keyword">self</span>.<span class="field">x</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 +68,14 @@ 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 control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> {
+        <span class="comment">// Do nothing</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..be57eeb0a 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)) => {
@@ -390,12 +403,13 @@ fn highlight_element(
                 T![break]
                 | T![continue]
                 | T![else]
-                | T![for]
                 | T![if]
                 | T![loop]
                 | T![match]
                 | T![return]
-                | T![while] => h | HighlightModifier::ControlFlow,
+                | T![while]
+                | T![in] => h | HighlightModifier::ControlFlow,
+                T![for] if !is_child_of_impl(element) => h | HighlightModifier::ControlFlow,
                 T![unsafe] => h | HighlightModifier::Unsafe,
                 _ => h,
             }
@@ -419,6 +433,13 @@ fn highlight_element(
     }
 }
 
+fn is_child_of_impl(element: SyntaxElement) -> bool {
+    match element.parent() {
+        Some(e) => e.kind() == IMPL_DEF,
+        _ => false,
+    }
+}
+
 fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
     match def {
         Definition::Macro(_) => HighlightTag::Macro,
@@ -431,10 +452,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..eb43a23da 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -17,6 +17,18 @@ struct Foo {
     pub y: i32,
 }
 
+trait Bar {
+    fn bar(&self) -> i32;
+}
+
+impl Bar for Foo {
+    fn bar(&self) -> i32 {
+        self.x
+    }
+}
+
+static mut STATIC_MUT: i32 = 0;
+
 fn foo<'a, T>() -> T {
     foo::<'a, i32>()
 }
@@ -40,7 +52,14 @@ fn main() {
         let x = 92;
         vec.push(Foo { x, y: 1 });
     }
-    unsafe { vec.set_len(0); }
+    unsafe {
+        vec.set_len(0);
+        STATIC_MUT = 1;
+    }
+
+    for e in vec {
+        // Do nothing
+    }
 
     let mut x = 42;
     let y = &mut x;
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index f990e3bb9..60c11178e 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,7 +6,7 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    Adt, Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
+    Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
     Semantics, TypeParam, Visibility,
 };
 use ra_prof::profile;
@@ -42,18 +42,10 @@ impl Definition {
     }
 
     pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
-        let module = self.module(db);
-
         match self {
             Definition::Macro(_) => None,
             Definition::Field(sf) => Some(sf.visibility(db)),
-            Definition::ModuleDef(def) => match def {
-                ModuleDef::EnumVariant(id) => {
-                    let parent = id.parent_enum(db);
-                    module?.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)))
-                }
-                _ => module?.visibility_of(db, def),
-            },
+            Definition::ModuleDef(def) => def.definition_visibility(db),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
             Definition::TypeParam(_) => None,
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(
-                        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(),
-                    );
+                    res.cfgs.insert(package_id, cfgs);
                 }
-
                 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/make.rs b/crates/ra_syntax/src/ast/make.rs
index 7b17fef49..12c5228f5 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -300,7 +300,12 @@ pub fn add_pub_crate_modifier(fn_def: ast::FnDef) -> ast::FnDef {
 
 fn ast_from_text<N: AstNode>(text: &str) -> N {
     let parse = SourceFile::parse(text);
-    let node = parse.tree().syntax().descendants().find_map(N::cast).unwrap();
+    let node = match parse.tree().syntax().descendants().find_map(N::cast) {
+        Some(it) => it,
+        None => {
+            panic!("Failed to make ast node `{}` from text {}", std::any::type_name::<N>(), text)
+        }
+    };
     let node = node.syntax().clone();
     let node = unroot(node);
     let node = N::cast(node).unwrap();
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/ra_toolchain/src/lib.rs b/crates/ra_toolchain/src/lib.rs
index 3c307a0ea..3d2865e09 100644
--- a/crates/ra_toolchain/src/lib.rs
+++ b/crates/ra_toolchain/src/lib.rs
@@ -53,10 +53,9 @@ fn lookup_in_path(exec: &str) -> bool {
     let paths = env::var_os("PATH").unwrap_or_default();
     let mut candidates = env::split_paths(&paths).flat_map(|path| {
         let candidate = path.join(&exec);
-        let with_exe = if env::consts::EXE_EXTENSION == "" {
-            None
-        } else {
-            Some(candidate.with_extension(env::consts::EXE_EXTENSION))
+        let with_exe = match env::consts::EXE_EXTENSION {
+            "" => None,
+            it => Some(candidate.with_extension(it)),
         };
         iter::once(candidate).chain(with_exe)
     });
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 22a84b50c..09908458d 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -60,7 +60,7 @@ fn main() -> Result<()> {
 
 fn setup_logging() -> Result<()> {
     std::env::set_var("RUST_BACKTRACE", "short");
-    env_logger::try_init()?;
+    env_logger::try_init_from_env("RA_LOG")?;
     ra_prof::init();
     Ok(())
 }
@@ -100,9 +100,8 @@ fn run_server() -> Result<()> {
         if let Some(value) = &initialize_params.initialization_options {
             config.update(value);
         }
-        if let Some(caps) = &initialize_params.capabilities.text_document {
-            config.update_caps(caps);
-        }
+        config.update_caps(&initialize_params.capabilities);
+
         config
     };
 
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index ccc38e3bb..53aee833d 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -9,7 +9,7 @@
 
 use std::{ffi::OsString, path::PathBuf};
 
-use lsp_types::TextDocumentClientCapabilities;
+use lsp_types::ClientCapabilities;
 use ra_flycheck::FlycheckConfig;
 use ra_ide::{CompletionConfig, InlayHintsConfig};
 use ra_project_model::CargoConfig;
@@ -70,6 +70,7 @@ pub struct ClientCapsConfig {
     pub line_folding_only: bool,
     pub hierarchical_symbols: bool,
     pub code_action_literals: bool,
+    pub work_done_progress: bool,
 }
 
 impl Default for Config {
@@ -208,30 +209,43 @@ impl Config {
         }
     }
 
-    pub fn update_caps(&mut self, caps: &TextDocumentClientCapabilities) {
-        if let Some(value) = caps.definition.as_ref().and_then(|it| it.link_support) {
-            self.client_caps.location_link = value;
-        }
-        if let Some(value) = caps.folding_range.as_ref().and_then(|it| it.line_folding_only) {
-            self.client_caps.line_folding_only = value
-        }
-        if let Some(value) =
-            caps.document_symbol.as_ref().and_then(|it| it.hierarchical_document_symbol_support)
-        {
-            self.client_caps.hierarchical_symbols = value
-        }
-        if let Some(value) =
-            caps.code_action.as_ref().and_then(|it| Some(it.code_action_literal_support.is_some()))
-        {
-            self.client_caps.code_action_literals = value;
-        }
-        self.completion.allow_snippets(false);
-        if let Some(completion) = &caps.completion {
-            if let Some(completion_item) = &completion.completion_item {
-                if let Some(value) = completion_item.snippet_support {
-                    self.completion.allow_snippets(value);
+    pub fn update_caps(&mut self, caps: &ClientCapabilities) {
+        if let Some(doc_caps) = caps.text_document.as_ref() {
+            if let Some(value) = doc_caps.definition.as_ref().and_then(|it| it.link_support) {
+                self.client_caps.location_link = value;
+            }
+            if let Some(value) = doc_caps.folding_range.as_ref().and_then(|it| it.line_folding_only)
+            {
+                self.client_caps.line_folding_only = value
+            }
+            if let Some(value) = doc_caps
+                .document_symbol
+                .as_ref()
+                .and_then(|it| it.hierarchical_document_symbol_support)
+            {
+                self.client_caps.hierarchical_symbols = value
+            }
+            if let Some(value) = doc_caps
+                .code_action
+                .as_ref()
+                .and_then(|it| Some(it.code_action_literal_support.is_some()))
+            {
+                self.client_caps.code_action_literals = value;
+            }
+            self.completion.allow_snippets(false);
+            if let Some(completion) = &doc_caps.completion {
+                if let Some(completion_item) = &completion.completion_item {
+                    if let Some(value) = completion_item.snippet_support {
+                        self.completion.allow_snippets(value);
+                    }
                 }
             }
         }
+
+        if let Some(window_caps) = caps.window.as_ref() {
+            if let Some(value) = window_caps.work_done_progress {
+                self.client_caps.work_done_progress = value;
+            }
+        }
     }
 }
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 cursor_position: Option<TextDocumentPositionParams>,
+    pub workspace_edit: lsp_types::WorkspaceEdit,
+    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 17b0b95b9..13d305b97 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 request =
-                request_new::<req::RegisterCapability>(loop_state.next_request_id(), params);
+            let params = lsp_types::RegistrationParams { registrations: vec![registration] };
+            let request = request_new::<lsp_types::request::RegisterCapability>(
+                loop_state.next_request_id(),
+                params,
+            );
             connection.sender.send(request.into()).unwrap();
         }
 
@@ -173,7 +174,6 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
     };
 
     loop_state.roots_total = world_state.vfs.read().n_roots();
-    loop_state.roots_scanned = 0;
 
     let pool = ThreadPool::default();
     let (task_sender, task_receiver) = unbounded::<Task>();
@@ -258,14 +258,14 @@ impl fmt::Debug for Event {
 
         match self {
             Event::Msg(Message::Notification(not)) => {
-                if notification_is::<req::DidOpenTextDocument>(not)
-                    || notification_is::<req::DidChangeTextDocument>(not)
+                if notification_is::<lsp_types::notification::DidOpenTextDocument>(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);
                 }
             }
@@ -400,10 +400,12 @@ fn loop_turn(
     }
 
     let max_in_flight_libs = pool.max_count().saturating_sub(2).max(1);
-    while loop_state.in_flight_libraries < max_in_flight_libs
-        && !loop_state.pending_libraries.is_empty()
-    {
-        let (root, files) = loop_state.pending_libraries.pop().unwrap();
+    while loop_state.in_flight_libraries < max_in_flight_libs {
+        let (root, files) = match loop_state.pending_libraries.pop() {
+            Some(it) => it,
+            None => break,
+        };
+
         loop_state.in_flight_libraries += 1;
         let sender = libdata_sender.clone();
         pool.execute(move || {
@@ -413,7 +415,8 @@ fn loop_turn(
         });
     }
 
-    let show_progress = !loop_state.workspace_loaded;
+    let show_progress =
+        !loop_state.workspace_loaded && world_state.config.client_caps.work_done_progress;
 
     if !loop_state.workspace_loaded
         && loop_state.roots_scanned == loop_state.roots_total
@@ -450,7 +453,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,
             );
@@ -500,45 +503,51 @@ fn on_request(
         request_received,
     };
     pool_dispatcher
-        .on_sync::<req::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
-        .on_sync::<req::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::<req::SelectionRangeRequest>(|s, p| {
+        .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
+        .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
+        .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), 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::<req::SyntaxTree>(handlers::handle_syntax_tree)?
-        .on::<req::ExpandMacro>(handlers::handle_expand_macro)?
-        .on::<req::OnTypeFormatting>(handlers::handle_on_type_formatting)?
-        .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)?
-        .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
-        .on::<req::GotoDefinition>(handlers::handle_goto_definition)?
-        .on::<req::GotoImplementation>(handlers::handle_goto_implementation)?
-        .on::<req::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
-        .on::<req::ParentModule>(handlers::handle_parent_module)?
-        .on::<req::Runnables>(handlers::handle_runnables)?
-        .on::<req::Completion>(handlers::handle_completion)?
-        .on::<req::CodeActionRequest>(handlers::handle_code_action)?
-        .on::<req::CodeLensRequest>(handlers::handle_code_lens)?
-        .on::<req::CodeLensResolve>(handlers::handle_code_lens_resolve)?
-        .on::<req::FoldingRangeRequest>(handlers::handle_folding_range)?
-        .on::<req::SignatureHelpRequest>(handlers::handle_signature_help)?
-        .on::<req::HoverRequest>(handlers::handle_hover)?
-        .on::<req::PrepareRenameRequest>(handlers::handle_prepare_rename)?
-        .on::<req::Rename>(handlers::handle_rename)?
-        .on::<req::References>(handlers::handle_references)?
-        .on::<req::Formatting>(handlers::handle_formatting)?
-        .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)?
-        .on::<req::InlayHints>(handlers::handle_inlay_hints)?
-        .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
-        .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
-        .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
-        .on::<req::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
-        .on::<req::SemanticTokensRangeRequest>(handlers::handle_semantic_tokens_range)?
-        .on::<req::Ssr>(handlers::handle_ssr)?
+        .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)?
+        .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)?
+        .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)?
+        .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)?
+        .on::<lsp_ext::Runnables>(handlers::handle_runnables)?
+        .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
+        .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
+        .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
+        .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
+        .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)?
+        .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)?
+        .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
+        .on::<lsp_types::request::Completion>(handlers::handle_completion)?
+        .on::<lsp_types::request::CodeActionRequest>(handlers::handle_code_action)?
+        .on::<lsp_types::request::CodeLensRequest>(handlers::handle_code_lens)?
+        .on::<lsp_types::request::CodeLensResolve>(handlers::handle_code_lens_resolve)?
+        .on::<lsp_types::request::FoldingRangeRequest>(handlers::handle_folding_range)?
+        .on::<lsp_types::request::SignatureHelpRequest>(handlers::handle_signature_help)?
+        .on::<lsp_types::request::HoverRequest>(handlers::handle_hover)?
+        .on::<lsp_types::request::PrepareRenameRequest>(handlers::handle_prepare_rename)?
+        .on::<lsp_types::request::Rename>(handlers::handle_rename)?
+        .on::<lsp_types::request::References>(handlers::handle_references)?
+        .on::<lsp_types::request::Formatting>(handlers::handle_formatting)?
+        .on::<lsp_types::request::DocumentHighlightRequest>(handlers::handle_document_highlight)?
+        .on::<lsp_types::request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
+        .on::<lsp_types::request::CallHierarchyIncomingCalls>(
+            handlers::handle_call_hierarchy_incoming,
+        )?
+        .on::<lsp_types::request::CallHierarchyOutgoingCalls>(
+            handlers::handle_call_hierarchy_outgoing,
+        )?
+        .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+        .on::<lsp_types::request::SemanticTokensRangeRequest>(
+            handlers::handle_semantic_tokens_range,
+        )?
+        .on::<lsp_ext::Ssr>(handlers::handle_ssr)?
         .finish();
     Ok(())
 }
@@ -549,7 +558,7 @@ fn on_notification(
     loop_state: &mut LoopState,
     not: Notification,
 ) -> Result<()> {
-    let not = match notification_cast::<req::Cancel>(not) {
+    let not = match notification_cast::<lsp_types::notification::Cancel>(not) {
         Ok(params) => {
             let id: RequestId = match params.id {
                 NumberOrString::Number(id) => id.into(),
@@ -567,7 +576,7 @@ fn on_notification(
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidOpenTextDocument>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidOpenTextDocument>(not) {
         Ok(params) => {
             let uri = params.text_document.uri;
             let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
@@ -580,11 +589,11 @@ fn on_notification(
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidChangeTextDocument>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidChangeTextDocument>(not) {
         Ok(params) => {
             let DidChangeTextDocumentParams { text_document, content_changes } = params;
             let world = state.snapshot();
-            let file_id = text_document.try_conv_with(&world)?;
+            let file_id = from_proto::file_id(&world, &text_document.uri)?;
             let line_index = world.analysis().file_line_index(file_id)?;
             let uri = text_document.uri;
             let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
@@ -595,7 +604,7 @@ fn on_notification(
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidSaveTextDocument>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidSaveTextDocument>(not) {
         Ok(_params) => {
             if let Some(flycheck) = &state.flycheck {
                 flycheck.update();
@@ -604,7 +613,7 @@ fn on_notification(
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidCloseTextDocument>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidCloseTextDocument>(not) {
         Ok(params) => {
             let uri = params.text_document.uri;
             let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
@@ -612,22 +621,22 @@ fn on_notification(
                 loop_state.subscriptions.remove_sub(FileId(file_id.0));
             }
             let params =
-                req::PublishDiagnosticsParams { uri, diagnostics: Vec::new(), version: None };
-            let not = notification_new::<req::PublishDiagnostics>(params);
+                lsp_types::PublishDiagnosticsParams { uri, diagnostics: Vec::new(), version: None };
+            let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
             msg_sender.send(not.into()).unwrap();
             return Ok(());
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidChangeConfiguration>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidChangeConfiguration>(not) {
         Ok(_) => {
             // As stated in https://github.com/microsoft/language-server-protocol/issues/676,
             // this notification's parameters should be ignored and the actual config queried separately.
             let request_id = loop_state.next_request_id();
-            let request = request_new::<req::WorkspaceConfiguration>(
+            let request = request_new::<lsp_types::request::WorkspaceConfiguration>(
                 request_id.clone(),
-                req::ConfigurationParams {
-                    items: vec![req::ConfigurationItem {
+                lsp_types::ConfigurationParams {
+                    items: vec![lsp_types::ConfigurationItem {
                         scope_uri: None,
                         section: Some("rust-analyzer".to_string()),
                     }],
@@ -640,7 +649,7 @@ fn on_notification(
         }
         Err(not) => not,
     };
-    let not = match notification_cast::<req::DidChangeWatchedFiles>(not) {
+    let not = match notification_cast::<lsp_types::notification::DidChangeWatchedFiles>(not) {
         Ok(params) => {
             let mut vfs = state.vfs.write();
             for change in params.changes {
@@ -694,7 +703,7 @@ fn apply_document_changes(
                     line_index = Cow::Owned(LineIndex::new(&old_text));
                 }
                 index_valid = IndexValid::UpToLineExclusive(range.start.line);
-                let range = range.conv_with(&line_index);
+                let range = from_proto::text_range(&line_index, range);
                 let mut text = old_text.to_owned();
                 match std::panic::catch_unwind(move || {
                     text.replace_range(Range::<usize>::from(range), &change.text);
@@ -742,12 +751,16 @@ fn on_check_task(
         }
 
         CheckTask::Status(progress) => {
-            let params = req::ProgressParams {
-                token: req::ProgressToken::String("rustAnalyzer/cargoWatcher".to_string()),
-                value: req::ProgressParamsValue::WorkDone(progress),
-            };
-            let not = notification_new::<req::Progress>(params);
-            task_sender.send(Task::Notify(not)).unwrap();
+            if world_state.config.client_caps.work_done_progress {
+                let params = lsp_types::ProgressParams {
+                    token: lsp_types::ProgressToken::String(
+                        "rustAnalyzer/cargoWatcher".to_string(),
+                    ),
+                    value: lsp_types::ProgressParamsValue::WorkDone(progress),
+                };
+                let not = notification_new::<lsp_types::notification::Progress>(params);
+                task_sender.send(Task::Notify(not)).unwrap();
+            }
         }
     };
 
@@ -768,8 +781,8 @@ fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state:
         };
 
         let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect();
-        let params = req::PublishDiagnosticsParams { uri, diagnostics, version: None };
-        let not = notification_new::<req::PublishDiagnostics>(params);
+        let params = lsp_types::PublishDiagnosticsParams { uri, diagnostics, version: None };
+        let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
         msg_sender.send(not.into()).unwrap();
     }
 }
@@ -782,10 +795,10 @@ fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) {
 
     match (prev, loop_state.workspace_loaded) {
         (None, false) => {
-            let work_done_progress_create = request_new::<req::WorkDoneProgressCreate>(
+            let work_done_progress_create = request_new::<lsp_types::request::WorkDoneProgressCreate>(
                 loop_state.next_request_id(),
                 WorkDoneProgressCreateParams {
-                    token: req::ProgressToken::String("rustAnalyzer/startup".into()),
+                    token: lsp_types::ProgressToken::String("rustAnalyzer/startup".into()),
                 },
             );
             sender.send(work_done_progress_create.into()).unwrap();
@@ -817,10 +830,11 @@ fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) {
     }
 
     fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) {
-        let notif = notification_new::<req::Progress>(req::ProgressParams {
-            token: req::ProgressToken::String("rustAnalyzer/startup".into()),
-            value: req::ProgressParamsValue::WorkDone(work_done_progress),
-        });
+        let notif =
+            notification_new::<lsp_types::notification::Progress>(lsp_types::ProgressParams {
+                token: lsp_types::ProgressToken::String("rustAnalyzer/startup".into()),
+                value: lsp_types::ProgressParamsValue::WorkDone(work_done_progress),
+            });
         sender.send(notif.into()).unwrap();
     }
 }
@@ -842,7 +856,7 @@ impl<'a> PoolDispatcher<'a> {
         f: fn(&mut WorldState, R::Params) -> Result<R::Result>,
     ) -> Result<&mut Self>
     where
-        R: req::Request + 'static,
+        R: lsp_types::request::Request + 'static,
         R::Params: DeserializeOwned + panic::UnwindSafe + 'static,
         R::Result: Serialize + 'static,
     {
@@ -865,7 +879,7 @@ impl<'a> PoolDispatcher<'a> {
     /// Dispatches the request onto thread pool
     fn on<R>(&mut self, f: fn(WorldSnapshot, R::Params) -> Result<R::Result>) -> Result<&mut Self>
     where
-        R: req::Request + 'static,
+        R: lsp_types::request::Request + 'static,
         R::Params: DeserializeOwned + Send + 'static,
         R::Result: Serialize + 'static,
     {
@@ -891,7 +905,7 @@ impl<'a> PoolDispatcher<'a> {
 
     fn parse<R>(&mut self) -> Option<(RequestId, R::Params)>
     where
-        R: req::Request + 'static,
+        R: lsp_types::request::Request + 'static,
         R::Params: DeserializeOwned + 'static,
     {
         let req = self.req.take()?;
@@ -928,7 +942,7 @@ impl<'a> PoolDispatcher<'a> {
 
 fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task
 where
-    R: req::Request + 'static,
+    R: lsp_types::request::Request + 'static,
     R::Params: DeserializeOwned + 'static,
     R::Result: Serialize + 'static,
 {
@@ -984,10 +998,14 @@ fn update_file_notifications_on_threadpool(
     }
 }
 
-pub fn show_message(typ: req::MessageType, message: impl Into<String>, sender: &Sender<Message>) {
+pub fn show_message(
+    typ: lsp_types::MessageType,
+    message: impl Into<String>,
+    sender: &Sender<Message>,
+) {
     let message = message.into();
-    let params = req::ShowMessageParams { typ, message };
-    let not = notification_new::<req::ShowMessage>(params);
+    let params = lsp_types::ShowMessageParams { typ, message };
+    let not = notification_new::<lsp_types::notification::ShowMessage>(params);
     sender.send(not.into()).unwrap();
 }
 
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index f4353af64..be8688bc3 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -22,6 +22,7 @@ use ra_ide::{
     Assist, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind, SearchScope,
 };
 use ra_prof::profile;
+use ra_project_model::TargetKind;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
@@ -31,18 +32,13 @@ use stdx::format_to;
 use crate::{
     cargo_target_spec::CargoTargetSpec,
     config::RustfmtConfig,
-    conv::{
-        to_call_hierarchy_item, to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith,
-        TryConvWithToVec,
-    },
     diagnostics::DiagnosticTask,
-    from_json,
-    req::{self, InlayHint, InlayHintsParams},
-    semantic_tokens::SemanticTokensBuilder,
+    from_json, from_proto,
+    lsp_ext::{self, InlayHint, InlayHintsParams},
+    to_proto,
     world::WorldSnapshot,
     LspError, Result,
 };
-use ra_project_model::TargetKind;
 
 pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
     let _p = profile("handle_analyzer_status");
@@ -56,48 +52,51 @@ pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
     Ok(buf)
 }
 
-pub fn handle_syntax_tree(world: WorldSnapshot, params: req::SyntaxTreeParams) -> Result<String> {
+pub fn handle_syntax_tree(
+    world: WorldSnapshot,
+    params: lsp_ext::SyntaxTreeParams,
+) -> Result<String> {
     let _p = profile("handle_syntax_tree");
-    let id = params.text_document.try_conv_with(&world)?;
+    let id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(id)?;
-    let text_range = params.range.map(|p| p.conv_with(&line_index));
+    let text_range = params.range.map(|r| from_proto::text_range(&line_index, r));
     let res = world.analysis().syntax_tree(id, text_range)?;
     Ok(res)
 }
 
 pub fn handle_expand_macro(
     world: WorldSnapshot,
-    params: req::ExpandMacroParams,
-) -> Result<Option<req::ExpandedMacro>> {
+    params: lsp_ext::ExpandMacroParams,
+) -> Result<Option<lsp_ext::ExpandedMacro>> {
     let _p = profile("handle_expand_macro");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let offset = params.position.map(|p| p.conv_with(&line_index));
+    let offset = params.position.map(|p| from_proto::offset(&line_index, p));
 
     match offset {
         None => Ok(None),
         Some(offset) => {
             let res = world.analysis().expand_macro(FilePosition { file_id, offset })?;
-            Ok(res.map(|it| req::ExpandedMacro { name: it.name, expansion: it.expansion }))
+            Ok(res.map(|it| lsp_ext::ExpandedMacro { name: it.name, expansion: it.expansion }))
         }
     }
 }
 
 pub fn handle_selection_range(
     world: WorldSnapshot,
-    params: req::SelectionRangeParams,
-) -> Result<Option<Vec<req::SelectionRange>>> {
+    params: lsp_types::SelectionRangeParams,
+) -> Result<Option<Vec<lsp_types::SelectionRange>>> {
     let _p = profile("handle_selection_range");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let res: Result<Vec<req::SelectionRange>> = params
+    let res: Result<Vec<lsp_types::SelectionRange>> = params
         .positions
         .into_iter()
-        .map_conv_with(&line_index)
         .map(|position| {
+            let offset = from_proto::offset(&line_index, position);
             let mut ranges = Vec::new();
             {
-                let mut range = TextRange::new(position, position);
+                let mut range = TextRange::new(offset, offset);
                 loop {
                     ranges.push(range);
                     let frange = FileRange { file_id, range };
@@ -109,13 +108,13 @@ pub fn handle_selection_range(
                     }
                 }
             }
-            let mut range = req::SelectionRange {
-                range: ranges.last().unwrap().conv_with(&line_index),
+            let mut range = lsp_types::SelectionRange {
+                range: to_proto::range(&line_index, *ranges.last().unwrap()),
                 parent: None,
             };
-            for r in ranges.iter().rev().skip(1) {
-                range = req::SelectionRange {
-                    range: r.conv_with(&line_index),
+            for &r in ranges.iter().rev().skip(1) {
+                range = lsp_types::SelectionRange {
+                    range: to_proto::range(&line_index, r),
                     parent: Some(Box::new(range)),
                 }
             }
@@ -128,57 +127,55 @@ pub fn handle_selection_range(
 
 pub fn handle_find_matching_brace(
     world: WorldSnapshot,
-    params: req::FindMatchingBraceParams,
+    params: lsp_ext::FindMatchingBraceParams,
 ) -> Result<Vec<Position>> {
     let _p = profile("handle_find_matching_brace");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let res = params
         .offsets
         .into_iter()
-        .map_conv_with(&line_index)
-        .map(|offset| {
-            if let Ok(Some(matching_brace_offset)) =
-                world.analysis().matching_brace(FilePosition { file_id, offset })
-            {
-                matching_brace_offset
-            } else {
-                offset
-            }
+        .map(|position| {
+            let offset = from_proto::offset(&line_index, position);
+            let offset = match world.analysis().matching_brace(FilePosition { file_id, offset }) {
+                Ok(Some(matching_brace_offset)) => matching_brace_offset,
+                Err(_) | Ok(None) => offset,
+            };
+            to_proto::position(&line_index, offset)
         })
-        .map_conv_with(&line_index)
         .collect();
     Ok(res)
 }
 
 pub fn handle_join_lines(
     world: WorldSnapshot,
-    params: req::JoinLinesParams,
-) -> Result<req::SourceChange> {
+    params: lsp_ext::JoinLinesParams,
+) -> Result<lsp_ext::SourceChange> {
     let _p = profile("handle_join_lines");
-    let frange = (&params.text_document, params.range).try_conv_with(&world)?;
-    world.analysis().join_lines(frange)?.try_conv_with(&world)
+    let frange = from_proto::file_range(&world, params.text_document, params.range)?;
+    let source_change = world.analysis().join_lines(frange)?;
+    to_proto::source_change(&world, source_change)
 }
 
 pub fn handle_on_enter(
     world: WorldSnapshot,
-    params: req::TextDocumentPositionParams,
-) -> Result<Option<req::SourceChange>> {
+    params: lsp_types::TextDocumentPositionParams,
+) -> Result<Option<lsp_ext::SourceChange>> {
     let _p = profile("handle_on_enter");
-    let position = params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params)?;
     match world.analysis().on_enter(position)? {
         None => Ok(None),
-        Some(edit) => Ok(Some(edit.try_conv_with(&world)?)),
+        Some(source_change) => to_proto::source_change(&world, source_change).map(Some),
     }
 }
 
 // Don't forget to add new trigger characters to `ServerCapabilities` in `caps.rs`.
 pub fn handle_on_type_formatting(
     world: WorldSnapshot,
-    params: req::DocumentOnTypeFormattingParams,
+    params: lsp_types::DocumentOnTypeFormattingParams,
 ) -> Result<Option<Vec<TextEdit>>> {
     let _p = profile("handle_on_type_formatting");
-    let mut position = params.text_document_position.try_conv_with(&world)?;
+    let mut position = from_proto::file_position(&world, params.text_document_position)?;
     let line_index = world.analysis().file_line_index(position.file_id)?;
     let line_endings = world.file_line_endings(position.file_id);
 
@@ -208,18 +205,17 @@ pub fn handle_on_type_formatting(
     // This should be a single-file edit
     let edit = edit.source_file_edits.pop().unwrap();
 
-    let change: Vec<TextEdit> = edit.edit.conv_with((&line_index, line_endings));
+    let change = to_proto::text_edit_vec(&line_index, line_endings, edit.edit);
     Ok(Some(change))
 }
 
 pub fn handle_document_symbol(
     world: WorldSnapshot,
-    params: req::DocumentSymbolParams,
-) -> Result<Option<req::DocumentSymbolResponse>> {
+    params: lsp_types::DocumentSymbolParams,
+) -> Result<Option<lsp_types::DocumentSymbolResponse>> {
     let _p = profile("handle_document_symbol");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let url = file_id.try_conv_with(&world)?;
 
     let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new();
 
@@ -227,10 +223,10 @@ pub fn handle_document_symbol(
         let doc_symbol = DocumentSymbol {
             name: symbol.label,
             detail: symbol.detail,
-            kind: symbol.kind.conv(),
+            kind: to_proto::symbol_kind(symbol.kind),
             deprecated: Some(symbol.deprecated),
-            range: symbol.node_range.conv_with(&line_index),
-            selection_range: symbol.navigation_range.conv_with(&line_index),
+            range: to_proto::range(&line_index, symbol.node_range),
+            selection_range: to_proto::range(&line_index, symbol.navigation_range),
             children: None,
         };
         parents.push((doc_symbol, symbol.parent));
@@ -249,40 +245,41 @@ pub fn handle_document_symbol(
         }
     }
 
-    if world.config.client_caps.hierarchical_symbols {
-        Ok(Some(document_symbols.into()))
+    let res = if world.config.client_caps.hierarchical_symbols {
+        document_symbols.into()
     } else {
+        let url = to_proto::url(&world, file_id)?;
         let mut symbol_information = Vec::<SymbolInformation>::new();
         for symbol in document_symbols {
             flatten_document_symbol(&symbol, None, &url, &mut symbol_information);
         }
+        symbol_information.into()
+    };
+    return Ok(Some(res));
 
-        Ok(Some(symbol_information.into()))
-    }
-}
-
-fn flatten_document_symbol(
-    symbol: &DocumentSymbol,
-    container_name: Option<String>,
-    url: &Url,
-    res: &mut Vec<SymbolInformation>,
-) {
-    res.push(SymbolInformation {
-        name: symbol.name.clone(),
-        kind: symbol.kind,
-        deprecated: symbol.deprecated,
-        location: Location::new(url.clone(), symbol.range),
-        container_name: container_name,
-    });
+    fn flatten_document_symbol(
+        symbol: &DocumentSymbol,
+        container_name: Option<String>,
+        url: &Url,
+        res: &mut Vec<SymbolInformation>,
+    ) {
+        res.push(SymbolInformation {
+            name: symbol.name.clone(),
+            kind: symbol.kind,
+            deprecated: symbol.deprecated,
+            location: Location::new(url.clone(), symbol.range),
+            container_name: container_name,
+        });
 
-    for child in symbol.children.iter().flatten() {
-        flatten_document_symbol(child, Some(symbol.name.clone()), url, res);
+        for child in symbol.children.iter().flatten() {
+            flatten_document_symbol(child, Some(symbol.name.clone()), url, res);
+        }
     }
 }
 
 pub fn handle_workspace_symbol(
     world: WorldSnapshot,
-    params: req::WorkspaceSymbolParams,
+    params: lsp_types::WorkspaceSymbolParams,
 ) -> Result<Option<Vec<SymbolInformation>>> {
     let _p = profile("handle_workspace_symbol");
     let all_symbols = params.query.contains('#');
@@ -313,8 +310,8 @@ pub fn handle_workspace_symbol(
         for nav in world.analysis().symbol_search(query)? {
             let info = SymbolInformation {
                 name: nav.name().to_string(),
-                kind: nav.kind().conv(),
-                location: nav.try_conv_with(world)?,
+                kind: to_proto::symbol_kind(nav.kind()),
+                location: to_proto::location(world, nav.file_range())?,
                 container_name: nav.container_name().map(|v| v.to_string()),
                 deprecated: None,
             };
@@ -326,63 +323,80 @@ pub fn handle_workspace_symbol(
 
 pub fn handle_goto_definition(
     world: WorldSnapshot,
-    params: req::GotoDefinitionParams,
-) -> Result<Option<req::GotoDefinitionResponse>> {
+    params: lsp_types::GotoDefinitionParams,
+) -> Result<Option<lsp_types::GotoDefinitionResponse>> {
     let _p = profile("handle_goto_definition");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
     let nav_info = match world.analysis().goto_definition(position)? {
         None => return Ok(None),
         Some(it) => it,
     };
-    let res = (position.file_id, nav_info).try_conv_with(&world)?;
+    let res = to_proto::goto_definition_response(
+        &world,
+        FileRange { file_id: position.file_id, range: nav_info.range },
+        nav_info.info,
+    )?;
     Ok(Some(res))
 }
 
 pub fn handle_goto_implementation(
     world: WorldSnapshot,
-    params: req::GotoImplementationParams,
-) -> Result<Option<req::GotoImplementationResponse>> {
+    params: lsp_types::request::GotoImplementationParams,
+) -> Result<Option<lsp_types::request::GotoImplementationResponse>> {
     let _p = profile("handle_goto_implementation");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
     let nav_info = match world.analysis().goto_implementation(position)? {
         None => return Ok(None),
         Some(it) => it,
     };
-    let res = (position.file_id, nav_info).try_conv_with(&world)?;
+    let res = to_proto::goto_definition_response(
+        &world,
+        FileRange { file_id: position.file_id, range: nav_info.range },
+        nav_info.info,
+    )?;
     Ok(Some(res))
 }
 
 pub fn handle_goto_type_definition(
     world: WorldSnapshot,
-    params: req::GotoTypeDefinitionParams,
-) -> Result<Option<req::GotoTypeDefinitionResponse>> {
+    params: lsp_types::request::GotoTypeDefinitionParams,
+) -> Result<Option<lsp_types::request::GotoTypeDefinitionResponse>> {
     let _p = profile("handle_goto_type_definition");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
     let nav_info = match world.analysis().goto_type_definition(position)? {
         None => return Ok(None),
         Some(it) => it,
     };
-    let res = (position.file_id, nav_info).try_conv_with(&world)?;
+    let res = to_proto::goto_definition_response(
+        &world,
+        FileRange { file_id: position.file_id, range: nav_info.range },
+        nav_info.info,
+    )?;
     Ok(Some(res))
 }
 
 pub fn handle_parent_module(
     world: WorldSnapshot,
-    params: req::TextDocumentPositionParams,
+    params: lsp_types::TextDocumentPositionParams,
 ) -> Result<Vec<Location>> {
     let _p = profile("handle_parent_module");
-    let position = params.try_conv_with(&world)?;
-    world.analysis().parent_module(position)?.iter().try_conv_with_to_vec(&world)
+    let position = from_proto::file_position(&world, params)?;
+    world
+        .analysis()
+        .parent_module(position)?
+        .into_iter()
+        .map(|it| to_proto::location(&world, it.file_range()))
+        .collect::<Result<Vec<_>>>()
 }
 
 pub fn handle_runnables(
     world: WorldSnapshot,
-    params: req::RunnablesParams,
-) -> Result<Vec<req::Runnable>> {
+    params: lsp_ext::RunnablesParams,
+) -> Result<Vec<lsp_ext::Runnable>> {
     let _p = profile("handle_runnables");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let offset = params.position.map(|it| it.conv_with(&line_index));
+    let offset = params.position.map(|it| from_proto::offset(&line_index, it));
     let mut res = Vec::new();
     let workspace_root = world.workspace_root_for(file_id);
     let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
@@ -408,7 +422,7 @@ pub fn handle_runnables(
     match cargo_spec {
         Some(spec) => {
             for &cmd in ["check", "test"].iter() {
-                res.push(req::Runnable {
+                res.push(lsp_ext::Runnable {
                     range: Default::default(),
                     label: format!("cargo {} -p {}", cmd, spec.package),
                     bin: "cargo".to_string(),
@@ -420,7 +434,7 @@ pub fn handle_runnables(
             }
         }
         None => {
-            res.push(req::Runnable {
+            res.push(lsp_ext::Runnable {
                 range: Default::default(),
                 label: "cargo check --workspace".to_string(),
                 bin: "cargo".to_string(),
@@ -436,10 +450,10 @@ pub fn handle_runnables(
 
 pub fn handle_completion(
     world: WorldSnapshot,
-    params: req::CompletionParams,
-) -> Result<Option<req::CompletionResponse>> {
+    params: lsp_types::CompletionParams,
+) -> Result<Option<lsp_types::CompletionResponse>> {
     let _p = profile("handle_completion");
-    let position = params.text_document_position.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position)?;
     let completion_triggered_after_single_colon = {
         let mut res = false;
         if let Some(ctx) = params.context {
@@ -468,8 +482,10 @@ pub fn handle_completion(
     };
     let line_index = world.analysis().file_line_index(position.file_id)?;
     let line_endings = world.file_line_endings(position.file_id);
-    let items: Vec<CompletionItem> =
-        items.into_iter().map(|item| item.conv_with((&line_index, line_endings))).collect();
+    let items: Vec<CompletionItem> = items
+        .into_iter()
+        .map(|item| to_proto::completion_item(&line_index, line_endings, item))
+        .collect();
 
     Ok(Some(items.into()))
 }
@@ -479,52 +495,51 @@ pub fn handle_folding_range(
     params: FoldingRangeParams,
 ) -> Result<Option<Vec<FoldingRange>>> {
     let _p = profile("handle_folding_range");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let folds = world.analysis().folding_ranges(file_id)?;
     let text = world.analysis().file_text(file_id)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let ctx = FoldConvCtx {
-        text: &text,
-        line_index: &line_index,
-        line_folding_only: world.config.client_caps.line_folding_only,
-    };
-    let res = Some(folds.into_iter().map_conv_with(&ctx).collect());
-    Ok(res)
+    let line_folding_only = world.config.client_caps.line_folding_only;
+    let res = folds
+        .into_iter()
+        .map(|it| to_proto::folding_range(&*text, &line_index, line_folding_only, it))
+        .collect();
+    Ok(Some(res))
 }
 
 pub fn handle_signature_help(
     world: WorldSnapshot,
-    params: req::SignatureHelpParams,
-) -> Result<Option<req::SignatureHelp>> {
+    params: lsp_types::SignatureHelpParams,
+) -> Result<Option<lsp_types::SignatureHelp>> {
     let _p = profile("handle_signature_help");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
-    if let Some(call_info) = world.analysis().call_info(position)? {
-        let concise = !world.config.call_info_full;
-        let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
-        if concise && call_info.signature.has_self_param {
-            active_parameter = active_parameter.map(|it| it.saturating_sub(1));
-        }
-        let sig_info = call_info.signature.conv_with(concise);
-
-        Ok(Some(req::SignatureHelp {
-            signatures: vec![sig_info],
-            active_signature: Some(0),
-            active_parameter,
-        }))
-    } else {
-        Ok(None)
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
+    let call_info = match world.analysis().call_info(position)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+    let concise = !world.config.call_info_full;
+    let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
+    if concise && call_info.signature.has_self_param {
+        active_parameter = active_parameter.map(|it| it.saturating_sub(1));
     }
+    let sig_info = to_proto::signature_information(call_info.signature, concise);
+
+    Ok(Some(lsp_types::SignatureHelp {
+        signatures: vec![sig_info],
+        active_signature: Some(0),
+        active_parameter,
+    }))
 }
 
-pub fn handle_hover(world: WorldSnapshot, params: req::HoverParams) -> Result<Option<Hover>> {
+pub fn handle_hover(world: WorldSnapshot, params: lsp_types::HoverParams) -> Result<Option<Hover>> {
     let _p = profile("handle_hover");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
     let info = match world.analysis().hover(position)? {
         None => return Ok(None),
         Some(info) => info,
     };
     let line_index = world.analysis.file_line_index(position.file_id)?;
-    let range = info.range.conv_with(&line_index);
+    let range = to_proto::range(&line_index, info.range);
     let res = Hover {
         contents: HoverContents::Markup(MarkupContent {
             kind: MarkupKind::Markdown,
@@ -537,10 +552,10 @@ pub fn handle_hover(world: WorldSnapshot, params: req::HoverParams) -> Result<Op
 
 pub fn handle_prepare_rename(
     world: WorldSnapshot,
-    params: req::TextDocumentPositionParams,
+    params: lsp_types::TextDocumentPositionParams,
 ) -> Result<Option<PrepareRenameResponse>> {
     let _p = profile("handle_prepare_rename");
-    let position = params.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params)?;
 
     let optional_change = world.analysis().rename(position, "dummy")?;
     let range = match optional_change {
@@ -548,15 +563,14 @@ pub fn handle_prepare_rename(
         Some(it) => it.range,
     };
 
-    let file_id = params.text_document.try_conv_with(&world)?;
-    let line_index = world.analysis().file_line_index(file_id)?;
-    let range = range.conv_with(&line_index);
+    let line_index = world.analysis().file_line_index(position.file_id)?;
+    let range = to_proto::range(&line_index, range);
     Ok(Some(PrepareRenameResponse::Range(range)))
 }
 
 pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
     let _p = profile("handle_rename");
-    let position = params.text_document_position.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position)?;
 
     if params.new_name.is_empty() {
         return Err(LspError::new(
@@ -567,22 +581,21 @@ pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Optio
     }
 
     let optional_change = world.analysis().rename(position, &*params.new_name)?;
-    let change = match optional_change {
+    let source_change = match optional_change {
         None => return Ok(None),
         Some(it) => it.info,
     };
 
-    let source_change_req = change.try_conv_with(&world)?;
-
-    Ok(Some(source_change_req.workspace_edit))
+    let source_change = to_proto::source_change(&world, source_change)?;
+    Ok(Some(source_change.workspace_edit))
 }
 
 pub fn handle_references(
     world: WorldSnapshot,
-    params: req::ReferenceParams,
+    params: lsp_types::ReferenceParams,
 ) -> Result<Option<Vec<Location>>> {
     let _p = profile("handle_references");
-    let position = params.text_document_position.try_conv_with(&world)?;
+    let position = from_proto::file_position(&world, params.text_document_position)?;
 
     let refs = match world.analysis().find_all_refs(position, None)? {
         None => return Ok(None),
@@ -591,33 +604,13 @@ pub fn handle_references(
 
     let locations = if params.context.include_declaration {
         refs.into_iter()
-            .filter_map(|reference| {
-                let line_index =
-                    world.analysis().file_line_index(reference.file_range.file_id).ok()?;
-                to_location(
-                    reference.file_range.file_id,
-                    reference.file_range.range,
-                    &world,
-                    &line_index,
-                )
-                .ok()
-            })
+            .filter_map(|reference| to_proto::location(&world, reference.file_range).ok())
             .collect()
     } else {
         // Only iterate over the references if include_declaration was false
         refs.references()
             .iter()
-            .filter_map(|reference| {
-                let line_index =
-                    world.analysis().file_line_index(reference.file_range.file_id).ok()?;
-                to_location(
-                    reference.file_range.file_id,
-                    reference.file_range.range,
-                    &world,
-                    &line_index,
-                )
-                .ok()
-            })
+            .filter_map(|reference| to_proto::location(&world, reference.file_range).ok())
             .collect()
     };
 
@@ -629,12 +622,12 @@ pub fn handle_formatting(
     params: DocumentFormattingParams,
 ) -> Result<Option<Vec<TextEdit>>> {
     let _p = profile("handle_formatting");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let file = world.analysis().file_text(file_id)?;
     let crate_ids = world.analysis().crate_for(file_id)?;
 
     let file_line_index = world.analysis().file_line_index(file_id)?;
-    let end_position = TextSize::of(file.as_str()).conv_with(&file_line_index);
+    let end_position = to_proto::position(&file_line_index, TextSize::of(file.as_str()));
 
     let mut rustfmt = match &world.config.rustfmt {
         RustfmtConfig::Rustfmt { extra_args } => {
@@ -700,33 +693,14 @@ pub fn handle_formatting(
     }]))
 }
 
-fn create_single_code_action(assist: Assist, world: &WorldSnapshot) -> Result<CodeAction> {
-    let arg = to_value(assist.source_change.try_conv_with(world)?)?;
-    let title = assist.label;
-    let command = Command {
-        title: title.clone(),
-        command: "rust-analyzer.applySourceChange".to_string(),
-        arguments: Some(vec![arg]),
-    };
-
-    Ok(CodeAction {
-        title,
-        kind: Some(String::new()),
-        diagnostics: None,
-        edit: None,
-        command: Some(command),
-        is_preferred: None,
-    })
-}
-
 pub fn handle_code_action(
     world: WorldSnapshot,
-    params: req::CodeActionParams,
+    params: lsp_types::CodeActionParams,
 ) -> Result<Option<CodeActionResponse>> {
     let _p = profile("handle_code_action");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let range = params.range.conv_with(&line_index);
+    let range = from_proto::text_range(&line_index, params.range);
 
     let diagnostics = world.analysis().diagnostics(file_id)?;
     let mut res = CodeActionResponse::default();
@@ -739,7 +713,7 @@ pub fn handle_code_action(
 
     for source_edit in fixes_from_diagnostics {
         let title = source_edit.label.clone();
-        let edit = source_edit.try_conv_with(&world)?;
+        let edit = to_proto::source_change(&world, source_edit)?;
 
         let command = Command {
             title,
@@ -758,7 +732,7 @@ pub fn handle_code_action(
     }
 
     for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
-        let fix_range = fix.range.conv_with(&line_index);
+        let fix_range = from_proto::text_range(&line_index, fix.range);
         if fix_range.intersect(range).is_none() {
             continue;
         }
@@ -779,21 +753,21 @@ pub fn handle_code_action(
                 .1
                 .push(assist),
             None => {
-                res.push(create_single_code_action(assist, &world)?.into());
+                res.push(to_proto::code_action(&world, assist)?.into());
             }
         }
     }
 
     for (group_label, (idx, assists)) in grouped_assists {
         if assists.len() == 1 {
-            res[idx] =
-                create_single_code_action(assists.into_iter().next().unwrap(), &world)?.into();
+            res[idx] = to_proto::code_action(&world, assists.into_iter().next().unwrap())?.into();
         } else {
             let title = group_label;
 
             let mut arguments = Vec::with_capacity(assists.len());
             for assist in assists {
-                arguments.push(to_value(assist.source_change.try_conv_with(&world)?)?);
+                let source_change = to_proto::source_change(&world, assist.source_change)?;
+                arguments.push(to_value(source_change)?);
             }
 
             let command = Some(Command {
@@ -835,10 +809,10 @@ pub fn handle_code_action(
 
 pub fn handle_code_lens(
     world: WorldSnapshot,
-    params: req::CodeLensParams,
+    params: lsp_types::CodeLensParams,
 ) -> Result<Option<Vec<CodeLens>>> {
     let _p = profile("handle_code_lens");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
 
     let mut lenses: Vec<CodeLens> = Default::default();
@@ -902,10 +876,10 @@ pub fn handle_code_lens(
                 _ => false,
             })
             .map(|it| {
-                let range = it.node_range.conv_with(&line_index);
+                let range = to_proto::range(&line_index, it.node_range);
                 let pos = range.start;
-                let lens_params = req::GotoImplementationParams {
-                    text_document_position_params: req::TextDocumentPositionParams::new(
+                let lens_params = lsp_types::request::GotoImplementationParams {
+                    text_document_position_params: lsp_types::TextDocumentPositionParams::new(
                         params.text_document.clone(),
                         pos,
                     ),
@@ -926,7 +900,7 @@ pub fn handle_code_lens(
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 enum CodeLensResolveData {
-    Impls(req::GotoImplementationParams),
+    Impls(lsp_types::request::GotoImplementationParams),
 }
 
 pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> {
@@ -937,9 +911,9 @@ pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Re
         Some(CodeLensResolveData::Impls(lens_params)) => {
             let locations: Vec<Location> =
                 match handle_goto_implementation(world, lens_params.clone())? {
-                    Some(req::GotoDefinitionResponse::Scalar(loc)) => vec![loc],
-                    Some(req::GotoDefinitionResponse::Array(locs)) => locs,
-                    Some(req::GotoDefinitionResponse::Link(links)) => links
+                    Some(lsp_types::GotoDefinitionResponse::Scalar(loc)) => vec![loc],
+                    Some(lsp_types::GotoDefinitionResponse::Array(locs)) => locs,
+                    Some(lsp_types::GotoDefinitionResponse::Link(links)) => links
                         .into_iter()
                         .map(|link| Location::new(link.target_uri, link.target_selection_range))
                         .collect(),
@@ -976,37 +950,39 @@ pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Re
 
 pub fn handle_document_highlight(
     world: WorldSnapshot,
-    params: req::DocumentHighlightParams,
+    params: lsp_types::DocumentHighlightParams,
 ) -> Result<Option<Vec<DocumentHighlight>>> {
     let _p = profile("handle_document_highlight");
-    let file_id = params.text_document_position_params.text_document.try_conv_with(&world)?;
-    let line_index = world.analysis().file_line_index(file_id)?;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
+    let line_index = world.analysis().file_line_index(position.file_id)?;
 
-    let refs = match world.analysis().find_all_refs(
-        params.text_document_position_params.try_conv_with(&world)?,
-        Some(SearchScope::single_file(file_id)),
-    )? {
+    let refs = match world
+        .analysis()
+        .find_all_refs(position, Some(SearchScope::single_file(position.file_id)))?
+    {
         None => return Ok(None),
         Some(refs) => refs,
     };
 
-    Ok(Some(
-        refs.into_iter()
-            .filter(|reference| reference.file_range.file_id == file_id)
-            .map(|reference| DocumentHighlight {
-                range: reference.file_range.range.conv_with(&line_index),
-                kind: reference.access.map(|it| it.conv()),
-            })
-            .collect(),
-    ))
+    let res = refs
+        .into_iter()
+        .filter(|reference| reference.file_range.file_id == position.file_id)
+        .map(|reference| DocumentHighlight {
+            range: to_proto::range(&line_index, reference.file_range.range),
+            kind: reference.access.map(to_proto::document_highlight_kind),
+        })
+        .collect();
+    Ok(Some(res))
 }
 
-pub fn handle_ssr(world: WorldSnapshot, params: req::SsrParams) -> Result<req::SourceChange> {
+pub fn handle_ssr(
+    world: WorldSnapshot,
+    params: lsp_ext::SsrParams,
+) -> Result<lsp_ext::SourceChange> {
     let _p = profile("handle_ssr");
-    world
-        .analysis()
-        .structural_search_replace(&params.query, params.parse_only)??
-        .try_conv_with(&world)
+    let source_change =
+        world.analysis().structural_search_replace(&params.query, params.parse_only)??;
+    to_proto::source_change(&world, source_change)
 }
 
 pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
@@ -1017,8 +993,8 @@ pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<Dia
         .diagnostics(file_id)?
         .into_iter()
         .map(|d| Diagnostic {
-            range: d.range.conv_with(&line_index),
-            severity: Some(d.severity.conv()),
+            range: to_proto::range(&line_index, d.range),
+            severity: Some(to_proto::diagnostic_severity(d.severity)),
             code: None,
             source: Some("rust-analyzer".to_string()),
             message: d.message,
@@ -1033,7 +1009,7 @@ fn to_lsp_runnable(
     world: &WorldSnapshot,
     file_id: FileId,
     runnable: Runnable,
-) -> Result<req::Runnable> {
+) -> Result<lsp_ext::Runnable> {
     let spec = CargoTargetSpec::for_file(world, file_id)?;
     let (args, extra_args) = CargoTargetSpec::runnable_args(spec, &runnable.kind)?;
     let line_index = world.analysis().file_line_index(file_id)?;
@@ -1044,8 +1020,8 @@ fn to_lsp_runnable(
         RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id),
         RunnableKind::Bin => "run binary".to_string(),
     };
-    Ok(req::Runnable {
-        range: runnable.range.conv_with(&line_index),
+    Ok(lsp_ext::Runnable {
+        range: to_proto::range(&line_index, runnable.range),
         label,
         bin: "cargo".to_string(),
         args,
@@ -1064,13 +1040,13 @@ pub fn handle_inlay_hints(
     params: InlayHintsParams,
 ) -> Result<Vec<InlayHint>> {
     let _p = profile("handle_inlay_hints");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let analysis = world.analysis();
     let line_index = analysis.file_line_index(file_id)?;
     Ok(analysis
         .inlay_hints(file_id, &world.config.inlay_hints)?
         .into_iter()
-        .map_conv_with(&line_index)
+        .map(|it| to_proto::inlay_int(&line_index, it))
         .collect())
 }
 
@@ -1079,21 +1055,19 @@ pub fn handle_call_hierarchy_prepare(
     params: CallHierarchyPrepareParams,
 ) -> Result<Option<Vec<CallHierarchyItem>>> {
     let _p = profile("handle_call_hierarchy_prepare");
-    let position = params.text_document_position_params.try_conv_with(&world)?;
-    let file_id = position.file_id;
+    let position = from_proto::file_position(&world, params.text_document_position_params)?;
 
     let nav_info = match world.analysis().call_hierarchy(position)? {
         None => return Ok(None),
         Some(it) => it,
     };
 
-    let line_index = world.analysis().file_line_index(file_id)?;
-    let RangeInfo { range, info: navs } = nav_info;
+    let RangeInfo { range: _, info: navs } = nav_info;
     let res = navs
         .into_iter()
         .filter(|it| it.kind() == SyntaxKind::FN_DEF)
-        .filter_map(|it| to_call_hierarchy_item(file_id, range, &world, &line_index, it).ok())
-        .collect();
+        .map(|it| to_proto::call_hierarchy_item(&world, it))
+        .collect::<Result<Vec<_>>>()?;
 
     Ok(Some(res))
 }
@@ -1106,7 +1080,7 @@ pub fn handle_call_hierarchy_incoming(
     let item = params.item;
 
     let doc = TextDocumentIdentifier::new(item.uri);
-    let frange: FileRange = (&doc, item.range).try_conv_with(&world)?;
+    let frange = from_proto::file_range(&world, doc, item.range)?;
     let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
 
     let call_items = match world.analysis().incoming_calls(fpos)? {
@@ -1119,11 +1093,14 @@ pub fn handle_call_hierarchy_incoming(
     for call_item in call_items.into_iter() {
         let file_id = call_item.target.file_id();
         let line_index = world.analysis().file_line_index(file_id)?;
-        let range = call_item.target.range();
-        let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?;
+        let item = to_proto::call_hierarchy_item(&world, call_item.target)?;
         res.push(CallHierarchyIncomingCall {
             from: item,
-            from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(),
+            from_ranges: call_item
+                .ranges
+                .into_iter()
+                .map(|it| to_proto::range(&line_index, it))
+                .collect(),
         });
     }
 
@@ -1138,7 +1115,7 @@ pub fn handle_call_hierarchy_outgoing(
     let item = params.item;
 
     let doc = TextDocumentIdentifier::new(item.uri);
-    let frange: FileRange = (&doc, item.range).try_conv_with(&world)?;
+    let frange = from_proto::file_range(&world, doc, item.range)?;
     let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
 
     let call_items = match world.analysis().outgoing_calls(fpos)? {
@@ -1151,11 +1128,14 @@ pub fn handle_call_hierarchy_outgoing(
     for call_item in call_items.into_iter() {
         let file_id = call_item.target.file_id();
         let line_index = world.analysis().file_line_index(file_id)?;
-        let range = call_item.target.range();
-        let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?;
+        let item = to_proto::call_hierarchy_item(&world, call_item.target)?;
         res.push(CallHierarchyOutgoingCall {
             to: item,
-            from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(),
+            from_ranges: call_item
+                .ranges
+                .into_iter()
+                .map(|it| to_proto::range(&line_index, it))
+                .collect(),
         });
     }
 
@@ -1168,26 +1148,13 @@ pub fn handle_semantic_tokens(
 ) -> Result<Option<SemanticTokensResult>> {
     let _p = profile("handle_semantic_tokens");
 
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let text = world.analysis().file_text(file_id)?;
     let line_index = world.analysis().file_line_index(file_id)?;
 
-    let mut builder = SemanticTokensBuilder::default();
-
-    for highlight_range in world.analysis().highlight(file_id)?.into_iter() {
-        let (token_index, modifier_bitset) = highlight_range.highlight.conv();
-        for mut range in line_index.lines(highlight_range.range) {
-            if text[range].ends_with('\n') {
-                range = TextRange::new(range.start(), range.end() - TextSize::of('\n'));
-            }
-            let range = range.conv_with(&line_index);
-            builder.push(range, token_index, modifier_bitset);
-        }
-    }
-
-    let tokens = builder.build();
-
-    Ok(Some(tokens.into()))
+    let highlights = world.analysis().highlight(file_id)?;
+    let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights);
+    Ok(Some(semantic_tokens.into()))
 }
 
 pub fn handle_semantic_tokens_range(
@@ -1196,17 +1163,11 @@ pub fn handle_semantic_tokens_range(
 ) -> Result<Option<SemanticTokensRangeResult>> {
     let _p = profile("handle_semantic_tokens_range");
 
-    let frange = (&params.text_document, params.range).try_conv_with(&world)?;
+    let frange = from_proto::file_range(&world, params.text_document, params.range)?;
+    let text = world.analysis().file_text(frange.file_id)?;
     let line_index = world.analysis().file_line_index(frange.file_id)?;
 
-    let mut builder = SemanticTokensBuilder::default();
-
-    for highlight_range in world.analysis().highlight_range(frange)?.into_iter() {
-        let (token_type, token_modifiers) = highlight_range.highlight.conv();
-        builder.push(highlight_range.range.conv_with(&line_index), token_type, token_modifiers);
-    }
-
-    let tokens = builder.build();
-
-    Ok(Some(tokens.into()))
+    let highlights = world.analysis().highlight_range(frange)?;
+    let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights);
+    Ok(Some(semantic_tokens.into()))
 }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
new file mode 100644
index 000000000..33c2fd595
--- /dev/null
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -0,0 +1,592 @@
+//! Conversion of rust-analyzer specific types to lsp_types equivalents.
+use ra_db::{FileId, FileRange};
+use ra_ide::{
+    translate_offset_with_edit, Assist, CompletionItem, CompletionItemKind, Documentation,
+    FileSystemEdit, Fold, FoldKind, FunctionSignature, Highlight, HighlightModifier, HighlightTag,
+    HighlightedRange, InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget,
+    ReferenceAccess, Severity, SourceChange, SourceFileEdit,
+};
+use ra_syntax::{SyntaxKind, TextRange, TextSize};
+use ra_text_edit::{Indel, TextEdit};
+use ra_vfs::LineEndings;
+
+use crate::{lsp_ext, semantic_tokens, world::WorldSnapshot, Result};
+
+pub(crate) fn position(line_index: &LineIndex, offset: TextSize) -> lsp_types::Position {
+    let line_col = line_index.line_col(offset);
+    let line = u64::from(line_col.line);
+    let character = u64::from(line_col.col_utf16);
+    lsp_types::Position::new(line, character)
+}
+
+pub(crate) fn range(line_index: &LineIndex, range: TextRange) -> lsp_types::Range {
+    let start = position(line_index, range.start());
+    let end = position(line_index, range.end());
+    lsp_types::Range::new(start, end)
+}
+
+pub(crate) fn symbol_kind(syntax_kind: SyntaxKind) -> lsp_types::SymbolKind {
+    match syntax_kind {
+        SyntaxKind::FN_DEF => lsp_types::SymbolKind::Function,
+        SyntaxKind::STRUCT_DEF => lsp_types::SymbolKind::Struct,
+        SyntaxKind::ENUM_DEF => lsp_types::SymbolKind::Enum,
+        SyntaxKind::ENUM_VARIANT => lsp_types::SymbolKind::EnumMember,
+        SyntaxKind::TRAIT_DEF => lsp_types::SymbolKind::Interface,
+        SyntaxKind::MACRO_CALL => lsp_types::SymbolKind::Function,
+        SyntaxKind::MODULE => lsp_types::SymbolKind::Module,
+        SyntaxKind::TYPE_ALIAS_DEF => lsp_types::SymbolKind::TypeParameter,
+        SyntaxKind::RECORD_FIELD_DEF => lsp_types::SymbolKind::Field,
+        SyntaxKind::STATIC_DEF => lsp_types::SymbolKind::Constant,
+        SyntaxKind::CONST_DEF => lsp_types::SymbolKind::Constant,
+        SyntaxKind::IMPL_DEF => lsp_types::SymbolKind::Object,
+        _ => lsp_types::SymbolKind::Variable,
+    }
+}
+
+pub(crate) fn document_highlight_kind(
+    reference_access: ReferenceAccess,
+) -> lsp_types::DocumentHighlightKind {
+    match reference_access {
+        ReferenceAccess::Read => lsp_types::DocumentHighlightKind::Read,
+        ReferenceAccess::Write => lsp_types::DocumentHighlightKind::Write,
+    }
+}
+
+pub(crate) fn diagnostic_severity(severity: Severity) -> lsp_types::DiagnosticSeverity {
+    match severity {
+        Severity::Error => lsp_types::DiagnosticSeverity::Error,
+        Severity::WeakWarning => lsp_types::DiagnosticSeverity::Hint,
+    }
+}
+
+pub(crate) fn documentation(documentation: Documentation) -> lsp_types::Documentation {
+    let value = crate::markdown::format_docs(documentation.as_str());
+    let markup_content = lsp_types::MarkupContent { kind: lsp_types::MarkupKind::Markdown, value };
+    lsp_types::Documentation::MarkupContent(markup_content)
+}
+
+pub(crate) fn insert_text_format(
+    insert_text_format: InsertTextFormat,
+) -> lsp_types::InsertTextFormat {
+    match insert_text_format {
+        InsertTextFormat::Snippet => lsp_types::InsertTextFormat::Snippet,
+        InsertTextFormat::PlainText => lsp_types::InsertTextFormat::PlainText,
+    }
+}
+
+pub(crate) fn completion_item_kind(
+    completion_item_kind: CompletionItemKind,
+) -> lsp_types::CompletionItemKind {
+    match completion_item_kind {
+        CompletionItemKind::Keyword => lsp_types::CompletionItemKind::Keyword,
+        CompletionItemKind::Snippet => lsp_types::CompletionItemKind::Snippet,
+        CompletionItemKind::Module => lsp_types::CompletionItemKind::Module,
+        CompletionItemKind::Function => lsp_types::CompletionItemKind::Function,
+        CompletionItemKind::Struct => lsp_types::CompletionItemKind::Struct,
+        CompletionItemKind::Enum => lsp_types::CompletionItemKind::Enum,
+        CompletionItemKind::EnumVariant => lsp_types::CompletionItemKind::EnumMember,
+        CompletionItemKind::BuiltinType => lsp_types::CompletionItemKind::Struct,
+        CompletionItemKind::Binding => lsp_types::CompletionItemKind::Variable,
+        CompletionItemKind::Field => lsp_types::CompletionItemKind::Field,
+        CompletionItemKind::Trait => lsp_types::CompletionItemKind::Interface,
+        CompletionItemKind::TypeAlias => lsp_types::CompletionItemKind::Struct,
+        CompletionItemKind::Const => lsp_types::CompletionItemKind::Constant,
+        CompletionItemKind::Static => lsp_types::CompletionItemKind::Value,
+        CompletionItemKind::Method => lsp_types::CompletionItemKind::Method,
+        CompletionItemKind::TypeParam => lsp_types::CompletionItemKind::TypeParameter,
+        CompletionItemKind::Macro => lsp_types::CompletionItemKind::Method,
+        CompletionItemKind::Attribute => lsp_types::CompletionItemKind::EnumMember,
+    }
+}
+
+pub(crate) fn text_edit(
+    line_index: &LineIndex,
+    line_endings: LineEndings,
+    indel: Indel,
+) -> lsp_types::TextEdit {
+    let range = range(line_index, indel.delete);
+    let new_text = match line_endings {
+        LineEndings::Unix => indel.insert,
+        LineEndings::Dos => indel.insert.replace('\n', "\r\n"),
+    };
+    lsp_types::TextEdit { range, new_text }
+}
+
+pub(crate) fn text_edit_vec(
+    line_index: &LineIndex,
+    line_endings: LineEndings,
+    text_edit: TextEdit,
+) -> Vec<lsp_types::TextEdit> {
+    text_edit
+        .as_indels()
+        .iter()
+        .map(|it| self::text_edit(line_index, line_endings, it.clone()))
+        .collect()
+}
+
+pub(crate) fn completion_item(
+    line_index: &LineIndex,
+    line_endings: LineEndings,
+    completion_item: CompletionItem,
+) -> 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.
+    let source_range = completion_item.source_range();
+    for indel in completion_item.text_edit().as_indels() {
+        if indel.delete.contains_range(source_range) {
+            text_edit = Some(if indel.delete == source_range {
+                self::text_edit(line_index, line_endings, indel.clone())
+            } else {
+                assert!(source_range.end() == indel.delete.end());
+                let range1 = TextRange::new(indel.delete.start(), source_range.start());
+                let range2 = source_range;
+                let indel1 = Indel::replace(range1, String::new());
+                let indel2 = Indel::replace(range2, indel.insert.clone());
+                additional_text_edits.push(self::text_edit(line_index, line_endings, indel1));
+                self::text_edit(line_index, line_endings, indel2)
+            })
+        } else {
+            assert!(source_range.intersect(indel.delete).is_none());
+            let text_edit = self::text_edit(line_index, line_endings, indel.clone());
+            additional_text_edits.push(text_edit);
+        }
+    }
+    let text_edit = text_edit.unwrap();
+
+    let mut res = lsp_types::CompletionItem {
+        label: completion_item.label().to_string(),
+        detail: completion_item.detail().map(|it| it.to_string()),
+        filter_text: Some(completion_item.lookup().to_string()),
+        kind: completion_item.kind().map(completion_item_kind),
+        text_edit: Some(text_edit.into()),
+        additional_text_edits: Some(additional_text_edits),
+        documentation: completion_item.documentation().map(documentation),
+        deprecated: Some(completion_item.deprecated()),
+        command: if completion_item.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 completion_item.score().is_some() {
+        res.preselect = Some(true)
+    }
+
+    if completion_item.deprecated() {
+        res.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated])
+    }
+
+    res.insert_text_format = Some(insert_text_format(completion_item.insert_text_format()));
+
+    res
+}
+
+pub(crate) fn signature_information(
+    signature: FunctionSignature,
+    concise: bool,
+) -> lsp_types::SignatureInformation {
+    let (label, documentation, params) = if concise {
+        let mut params = signature.parameters;
+        if signature.has_self_param {
+            params.remove(0);
+        }
+        (params.join(", "), None, params)
+    } else {
+        (signature.to_string(), signature.doc.map(documentation), signature.parameters)
+    };
+
+    let parameters: Vec<lsp_types::ParameterInformation> = params
+        .into_iter()
+        .map(|param| lsp_types::ParameterInformation {
+            label: lsp_types::ParameterLabel::Simple(param),
+            documentation: None,
+        })
+        .collect();
+
+    lsp_types::SignatureInformation { label, documentation, parameters: Some(parameters) }
+}
+
+pub(crate) fn inlay_int(line_index: &LineIndex, inlay_hint: InlayHint) -> lsp_ext::InlayHint {
+    lsp_ext::InlayHint {
+        label: inlay_hint.label.to_string(),
+        range: range(line_index, inlay_hint.range),
+        kind: match inlay_hint.kind {
+            InlayKind::ParameterHint => lsp_ext::InlayKind::ParameterHint,
+            InlayKind::TypeHint => lsp_ext::InlayKind::TypeHint,
+            InlayKind::ChainingHint => lsp_ext::InlayKind::ChainingHint,
+        },
+    }
+}
+
+pub(crate) fn semantic_tokens(
+    text: &str,
+    line_index: &LineIndex,
+    highlights: Vec<HighlightedRange>,
+) -> lsp_types::SemanticTokens {
+    let mut builder = semantic_tokens::SemanticTokensBuilder::default();
+
+    for highlight_range in highlights {
+        let (type_, mods) = semantic_token_type_and_modifiers(highlight_range.highlight);
+        let token_index = semantic_tokens::type_index(type_);
+        let modifier_bitset = mods.0;
+
+        for mut text_range in line_index.lines(highlight_range.range) {
+            if text[text_range].ends_with('\n') {
+                text_range =
+                    TextRange::new(text_range.start(), text_range.end() - TextSize::of('\n'));
+            }
+            let range = range(&line_index, text_range);
+            builder.push(range, token_index, modifier_bitset);
+        }
+    }
+
+    builder.build()
+}
+
+fn semantic_token_type_and_modifiers(
+    highlight: Highlight,
+) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) {
+    let mut mods = semantic_tokens::ModifierSet::default();
+    let type_ = match highlight.tag {
+        HighlightTag::Struct => lsp_types::SemanticTokenType::STRUCT,
+        HighlightTag::Enum => lsp_types::SemanticTokenType::ENUM,
+        HighlightTag::Union => semantic_tokens::UNION,
+        HighlightTag::TypeAlias => semantic_tokens::TYPE_ALIAS,
+        HighlightTag::Trait => lsp_types::SemanticTokenType::INTERFACE,
+        HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
+        HighlightTag::SelfType => lsp_types::SemanticTokenType::TYPE,
+        HighlightTag::Field => lsp_types::SemanticTokenType::PROPERTY,
+        HighlightTag::Function => lsp_types::SemanticTokenType::FUNCTION,
+        HighlightTag::Module => lsp_types::SemanticTokenType::NAMESPACE,
+        HighlightTag::Constant => {
+            mods |= semantic_tokens::CONSTANT;
+            mods |= lsp_types::SemanticTokenModifier::STATIC;
+            lsp_types::SemanticTokenType::VARIABLE
+        }
+        HighlightTag::Static => {
+            mods |= lsp_types::SemanticTokenModifier::STATIC;
+            lsp_types::SemanticTokenType::VARIABLE
+        }
+        HighlightTag::EnumVariant => semantic_tokens::ENUM_MEMBER,
+        HighlightTag::Macro => lsp_types::SemanticTokenType::MACRO,
+        HighlightTag::Local => lsp_types::SemanticTokenType::VARIABLE,
+        HighlightTag::TypeParam => lsp_types::SemanticTokenType::TYPE_PARAMETER,
+        HighlightTag::Lifetime => semantic_tokens::LIFETIME,
+        HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => {
+            lsp_types::SemanticTokenType::NUMBER
+        }
+        HighlightTag::CharLiteral | HighlightTag::StringLiteral => {
+            lsp_types::SemanticTokenType::STRING
+        }
+        HighlightTag::Comment => lsp_types::SemanticTokenType::COMMENT,
+        HighlightTag::Attribute => semantic_tokens::ATTRIBUTE,
+        HighlightTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
+        HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
+        HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
+    };
+
+    for modifier in highlight.modifiers.iter() {
+        let modifier = match modifier {
+            HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
+            HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW,
+            HighlightModifier::Mutable => semantic_tokens::MUTABLE,
+            HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
+        };
+        mods |= modifier;
+    }
+
+    (type_, mods)
+}
+
+pub(crate) fn folding_range(
+    text: &str,
+    line_index: &LineIndex,
+    line_folding_only: bool,
+    fold: Fold,
+) -> lsp_types::FoldingRange {
+    let kind = match fold.kind {
+        FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment),
+        FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports),
+        FoldKind::Mods | FoldKind::Block => None,
+    };
+
+    let range = range(line_index, fold.range);
+
+    if 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 = text[TextRange::new(fold.range.end(), TextSize::of(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,
+        }
+    }
+}
+
+pub(crate) fn url(world: &WorldSnapshot, file_id: FileId) -> Result<lsp_types::Url> {
+    world.file_id_to_uri(file_id)
+}
+
+pub(crate) fn text_document_identifier(
+    world: &WorldSnapshot,
+    file_id: FileId,
+) -> Result<lsp_types::TextDocumentIdentifier> {
+    let res = lsp_types::TextDocumentIdentifier { uri: url(world, file_id)? };
+    Ok(res)
+}
+
+pub(crate) fn versioned_text_document_identifier(
+    world: &WorldSnapshot,
+    file_id: FileId,
+    version: Option<i64>,
+) -> Result<lsp_types::VersionedTextDocumentIdentifier> {
+    let res = lsp_types::VersionedTextDocumentIdentifier { uri: url(world, file_id)?, version };
+    Ok(res)
+}
+
+pub(crate) fn location(world: &WorldSnapshot, frange: FileRange) -> Result<lsp_types::Location> {
+    let url = url(world, frange.file_id)?;
+    let line_index = world.analysis().file_line_index(frange.file_id)?;
+    let range = range(&line_index, frange.range);
+    let loc = lsp_types::Location::new(url, range);
+    Ok(loc)
+}
+
+pub(crate) fn location_link(
+    world: &WorldSnapshot,
+    src: FileRange,
+    target: NavigationTarget,
+) -> Result<lsp_types::LocationLink> {
+    let src_location = location(world, src)?;
+    let (target_uri, target_range, target_selection_range) = location_info(world, target)?;
+    let res = lsp_types::LocationLink {
+        origin_selection_range: Some(src_location.range),
+        target_uri,
+        target_range,
+        target_selection_range,
+    };
+    Ok(res)
+}
+
+fn location_info(
+    world: &WorldSnapshot,
+    target: NavigationTarget,
+) -> Result<(lsp_types::Url, lsp_types::Range, lsp_types::Range)> {
+    let line_index = world.analysis().file_line_index(target.file_id())?;
+
+    let target_uri = url(world, target.file_id())?;
+    let target_range = range(&line_index, target.full_range());
+    let target_selection_range =
+        target.focus_range().map(|it| range(&line_index, it)).unwrap_or(target_range);
+    Ok((target_uri, target_range, target_selection_range))
+}
+
+pub(crate) fn goto_definition_response(
+    world: &WorldSnapshot,
+    src: FileRange,
+    targets: Vec<NavigationTarget>,
+) -> Result<lsp_types::GotoDefinitionResponse> {
+    if world.config.client_caps.location_link {
+        let links = targets
+            .into_iter()
+            .map(|nav| location_link(world, src, nav))
+            .collect::<Result<Vec<_>>>()?;
+        Ok(links.into())
+    } else {
+        let locations = targets
+            .into_iter()
+            .map(|nav| {
+                location(
+                    world,
+                    FileRange {
+                        file_id: nav.file_id(),
+                        range: nav.focus_range().unwrap_or(nav.range()),
+                    },
+                )
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(locations.into())
+    }
+}
+
+pub(crate) fn text_document_edit(
+    world: &WorldSnapshot,
+    source_file_edit: SourceFileEdit,
+) -> Result<lsp_types::TextDocumentEdit> {
+    let text_document = versioned_text_document_identifier(world, source_file_edit.file_id, None)?;
+    let line_index = world.analysis().file_line_index(source_file_edit.file_id)?;
+    let line_endings = world.file_line_endings(source_file_edit.file_id);
+    let edits = source_file_edit
+        .edit
+        .as_indels()
+        .iter()
+        .map(|it| text_edit(&line_index, line_endings, it.clone()))
+        .collect();
+    Ok(lsp_types::TextDocumentEdit { text_document, edits })
+}
+
+pub(crate) fn resource_op(
+    world: &WorldSnapshot,
+    file_system_edit: FileSystemEdit,
+) -> Result<lsp_types::ResourceOp> {
+    let res = match file_system_edit {
+        FileSystemEdit::CreateFile { source_root, path } => {
+            let uri = world.path_to_uri(source_root, &path)?;
+            lsp_types::ResourceOp::Create(lsp_types::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)?;
+            lsp_types::ResourceOp::Rename(lsp_types::RenameFile { old_uri, new_uri, options: None })
+        }
+    };
+    Ok(res)
+}
+
+pub(crate) fn source_change(
+    world: &WorldSnapshot,
+    source_change: SourceChange,
+) -> Result<lsp_ext::SourceChange> {
+    let cursor_position = match source_change.cursor_position {
+        None => None,
+        Some(pos) => {
+            let line_index = world.analysis().file_line_index(pos.file_id)?;
+            let edit = source_change
+                .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 =
+                lsp_types::Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16));
+            Some(lsp_types::TextDocumentPositionParams {
+                text_document: text_document_identifier(world, pos.file_id)?,
+                position,
+            })
+        }
+    };
+    let mut document_changes: Vec<lsp_types::DocumentChangeOperation> = Vec::new();
+    for op in source_change.file_system_edits {
+        let op = resource_op(&world, op)?;
+        document_changes.push(lsp_types::DocumentChangeOperation::Op(op));
+    }
+    for edit in source_change.source_file_edits {
+        let edit = text_document_edit(&world, edit)?;
+        document_changes.push(lsp_types::DocumentChangeOperation::Edit(edit));
+    }
+    let workspace_edit = lsp_types::WorkspaceEdit {
+        changes: None,
+        document_changes: Some(lsp_types::DocumentChanges::Operations(document_changes)),
+    };
+    Ok(lsp_ext::SourceChange { label: source_change.label, workspace_edit, cursor_position })
+}
+
+pub fn call_hierarchy_item(
+    world: &WorldSnapshot,
+    target: NavigationTarget,
+) -> Result<lsp_types::CallHierarchyItem> {
+    let name = target.name().to_string();
+    let detail = target.description().map(|it| it.to_string());
+    let kind = symbol_kind(target.kind());
+    let (uri, range, selection_range) = location_info(world, target)?;
+    Ok(lsp_types::CallHierarchyItem { name, kind, tags: None, detail, uri, range, selection_range })
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::extract_ranges;
+
+    use super::*;
+
+    #[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 converted: Vec<lsp_types::FoldingRange> =
+            folds.into_iter().map(|it| folding_range(&text, &line_index, true, it)).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);
+        }
+    }
+}
+
+pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_types::CodeAction> {
+    let source_change = source_change(&world, assist.source_change)?;
+    let arg = serde_json::to_value(source_change)?;
+    let title = assist.label;
+    let command = lsp_types::Command {
+        title: title.clone(),
+        command: "rust-analyzer.applySourceChange".to_string(),
+        arguments: Some(vec![arg]),
+    };
+
+    Ok(lsp_types::CodeAction {
+        title,
+        kind: Some(String::new()),
+        diagnostics: None,
+        edit: None,
+        command: Some(command),
+        is_preferred: None,
+    })
+}
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 16020648d..6333c15b2 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -137,15 +137,6 @@ impl WorldState {
             opts
         };
 
-        // Create crate graph from all the workspaces
-        let mut crate_graph = CrateGraph::default();
-        let mut load = |path: &std::path::Path| {
-            // Some path from metadata will be non canonicalized, e.g. /foo/../bar/lib.rs
-            let path = path.canonicalize().ok()?;
-            let vfs_file = vfs.load(&path);
-            vfs_file.map(|f| FileId(f.0))
-        };
-
         let proc_macro_client = match &config.proc_macro_srv {
             None => ProcMacroClient::dummy(),
             Some((path, args)) => match ProcMacroClient::extern_process(path.into(), args) {
@@ -161,19 +152,22 @@ impl WorldState {
             },
         };
 
-        workspaces
-            .iter()
-            .map(|ws| {
-                ws.to_crate_graph(
-                    &default_cfg_options,
-                    &extern_source_roots,
-                    &proc_macro_client,
-                    &mut load,
-                )
-            })
-            .for_each(|graph| {
-                crate_graph.extend(graph);
-            });
+        // Create crate graph from all the workspaces
+        let mut crate_graph = CrateGraph::default();
+        let mut load = |path: &Path| {
+            // Some path from metadata will be non canonicalized, e.g. /foo/../bar/lib.rs
+            let path = path.canonicalize().ok()?;
+            let vfs_file = vfs.load(&path);
+            vfs_file.map(|f| FileId(f.0))
+        };
+        for ws in workspaces.iter() {
+            crate_graph.extend(ws.to_crate_graph(
+                &default_cfg_options,
+                &extern_source_roots,
+                &proc_macro_client,
+                &mut load,
+            ));
+        }
         change.set_crate_graph(crate_graph);
 
         let flycheck = config.check.as_ref().and_then(|c| create_flycheck(&workspaces, c));
diff --git a/crates/rust-analyzer/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs
index e459e3a3c..5011cc273 100644
--- a/crates/rust-analyzer/tests/heavy_tests/main.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/main.rs
@@ -3,15 +3,16 @@ mod support;
 use std::{collections::HashMap, path::PathBuf, time::Instant};
 
 use lsp_types::{
-    CodeActionContext, DidOpenTextDocumentParams, DocumentFormattingParams, FormattingOptions,
-    GotoDefinitionParams, HoverParams, PartialResultParams, Position, Range, TextDocumentItem,
-    TextDocumentPositionParams, WorkDoneProgressParams,
-};
-use rust_analyzer::req::{
-    CodeActionParams, CodeActionRequest, Completion, CompletionParams, DidOpenTextDocument,
-    Formatting, GotoDefinition, GotoTypeDefinition, HoverRequest, OnEnter, Runnables,
-    RunnablesParams,
+    notification::DidOpenTextDocument,
+    request::{
+        CodeActionRequest, Completion, Formatting, GotoDefinition, GotoTypeDefinition, HoverRequest,
+    },
+    CodeActionContext, CodeActionParams, CompletionParams, DidOpenTextDocumentParams,
+    DocumentFormattingParams, FormattingOptions, GotoDefinitionParams, HoverParams,
+    PartialResultParams, Position, Range, TextDocumentItem, TextDocumentPositionParams,
+    WorkDoneProgressParams,
 };
+use rust_analyzer::lsp_ext::{OnEnter, Runnables, RunnablesParams};
 use serde_json::json;
 use tempfile::TempDir;
 use test_utils::skip_slow_tests;
diff --git a/crates/rust-analyzer/tests/heavy_tests/support.rs b/crates/rust-analyzer/tests/heavy_tests/support.rs
index 8d47ee4f6..9acbae066 100644
--- a/crates/rust-analyzer/tests/heavy_tests/support.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/support.rs
@@ -13,15 +13,15 @@ use lsp_types::{
     request::Shutdown,
     DidOpenTextDocumentParams, TextDocumentIdentifier, TextDocumentItem, Url, WorkDoneProgress,
 };
+use lsp_types::{ProgressParams, ProgressParamsValue};
 use serde::Serialize;
 use serde_json::{to_string_pretty, Value};
 use tempfile::TempDir;
 use test_utils::{find_mismatch, parse_fixture};
 
-use req::{ProgressParams, ProgressParamsValue};
 use rust_analyzer::{
     config::{ClientCapsConfig, Config},
-    main_loop, req,
+    main_loop,
 };
 
 pub struct Project<'a> {
@@ -80,6 +80,7 @@ impl<'a> Project<'a> {
             client_caps: ClientCapsConfig {
                 location_link: true,
                 code_action_literals: true,
+                work_done_progress: true,
                 ..Default::default()
             },
             with_sysroot: self.with_sysroot,
@@ -206,7 +207,7 @@ impl Server {
             Message::Notification(n) if n.method == "$/progress" => {
                 match n.clone().extract::<ProgressParams>("$/progress").unwrap() {
                     ProgressParams {
-                        token: req::ProgressToken::String(ref token),
+                        token: lsp_types::ProgressToken::String(ref token),
                         value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(_)),
                     } if token == "rustAnalyzer/startup" => true,
                     _ => false,