1 files changed, 396 insertions, 404 deletions

diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 0f623949e..121964718 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -11,17 +11,18 @@ use lsp_server::ErrorCode;
 use lsp_types::{
     CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
     CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
-    CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
-    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams,
-    Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
-    Range, RenameParams, SemanticTokensParams, SemanticTokensRangeParams,
-    SemanticTokensRangeResult, SemanticTokensResult, SymbolInformation, TextDocumentIdentifier,
-    TextEdit, Url, WorkspaceEdit,
+    CodeLens, Command, CompletionItem, Diagnostic, DocumentFormattingParams, DocumentHighlight,
+    DocumentSymbol, FoldingRange, FoldingRangeParams, Hover, HoverContents, Location,
+    MarkupContent, MarkupKind, Position, PrepareRenameResponse, Range, RenameParams,
+    SemanticTokensParams, SemanticTokensRangeParams, SemanticTokensRangeResult,
+    SemanticTokensResult, SymbolInformation, TextDocumentIdentifier, Url, WorkspaceEdit,
 };
 use ra_ide::{
     Assist, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind, SearchScope,
+    TextEdit,
 };
 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,14 +32,10 @@ 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,
 };
@@ -46,57 +43,60 @@ use crate::{
 pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
     let _p = profile("handle_analyzer_status");
     let mut buf = world.status();
-    format_to!(buf, "\n\nrequests:");
+    format_to!(buf, "\n\nrequests:\n");
     let requests = world.latest_requests.read();
     for (is_last, r) in requests.iter() {
         let mark = if is_last { "*" } else { " " };
-        format_to!(buf, "{}{:4} {:<36}{}ms", mark, r.id, r.method, r.duration.as_millis());
+        format_to!(buf, "{}{:4} {:<36}{}ms\n", mark, r.id, r.method, r.duration.as_millis());
     }
     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 };
@@ -108,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)),
                 }
             }
@@ -127,57 +127,68 @@ 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<Vec<lsp_types::TextEdit>> {
     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 file_id = from_proto::file_id(&world, &params.text_document.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let line_endings = world.file_line_endings(file_id);
+    let mut res = TextEdit::default();
+    for range in params.ranges {
+        let range = from_proto::text_range(&line_index, range);
+        let edit = world.analysis().join_lines(FileRange { file_id, range })?;
+        match res.union(edit) {
+            Ok(()) => (),
+            Err(_edit) => {
+                // just ignore overlapping edits
+            }
+        }
+    }
+    let res = to_proto::text_edit_vec(&line_index, line_endings, res);
+    Ok(res)
 }
 
 pub fn handle_on_enter(
     world: WorldSnapshot,
-    params: req::TextDocumentPositionParams,
-) -> Result<Option<req::SourceChange>> {
+    params: lsp_types::TextDocumentPositionParams,
+) -> Result<Option<lsp_ext::SnippetWorkspaceEdit>> {
     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::snippet_workspace_edit(&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,
-) -> Result<Option<Vec<TextEdit>>> {
+    params: lsp_types::DocumentOnTypeFormattingParams,
+) -> Result<Option<Vec<lsp_types::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);
 
@@ -207,18 +218,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();
 
@@ -226,10 +236,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));
@@ -248,40 +258,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('#');
@@ -312,8 +323,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,
             };
@@ -325,86 +336,110 @@ 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)?;
     for runnable in world.analysis().runnables(file_id)? {
         if let Some(offset) = offset {
             if !runnable.range.contains_inclusive(offset) {
                 continue;
             }
         }
+        // Do not suggest binary run on other target than binary
+        if let RunnableKind::Bin = runnable.kind {
+            if let Some(spec) = &cargo_spec {
+                match spec.target_kind {
+                    TargetKind::Bin => {}
+                    _ => continue,
+                }
+            }
+        }
         res.push(to_lsp_runnable(&world, file_id, runnable)?);
     }
+
     // Add `cargo check` and `cargo test` for the whole package
-    match CargoTargetSpec::for_file(&world, file_id)? {
+    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(),
-                    args: {
-                        let mut args = vec![cmd.to_string()];
-                        spec.clone().push_to(&mut args);
-                        args
-                    },
+                    args: vec![cmd.to_string(), "--package".to_string(), spec.package.clone()],
                     extra_args: Vec::new(),
                     env: FxHashMap::default(),
                     cwd: workspace_root.map(|root| root.to_owned()),
@@ -412,7 +447,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(),
@@ -428,10 +463,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 {
@@ -454,14 +489,16 @@ pub fn handle_completion(
         return Ok(None);
     }
 
-    let items = match world.analysis().completions(position, &world.config.completion)? {
+    let items = match world.analysis().completions(&world.config.completion, position)? {
         None => return Ok(None),
         Some(items) => items,
     };
     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()))
 }
@@ -471,52 +508,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,
@@ -529,10 +565,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 {
@@ -540,15 +576,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(
@@ -559,22 +594,20 @@ 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 workspace_edit = to_proto::workspace_edit(&world, source_change)?;
+    Ok(Some(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),
@@ -583,33 +616,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()
     };
 
@@ -619,14 +632,14 @@ pub fn handle_references(
 pub fn handle_formatting(
     world: WorldSnapshot,
     params: DocumentFormattingParams,
-) -> Result<Option<Vec<TextEdit>>> {
+) -> Result<Option<Vec<lsp_types::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 } => {
@@ -686,42 +699,30 @@ pub fn handle_formatting(
         }
     }
 
-    Ok(Some(vec![TextEdit {
+    Ok(Some(vec![lsp_types::TextEdit {
         range: Range::new(Position::new(0, 0), end_position),
         new_text: captured_stdout,
     }]))
 }
 
-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,
-) -> Result<Option<CodeActionResponse>> {
+    params: lsp_types::CodeActionParams,
+) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
     let _p = profile("handle_code_action");
-    let file_id = params.text_document.try_conv_with(&world)?;
+    // We intentionally don't support command-based actions, as those either
+    // requires custom client-code anyway, or requires server-initiated edits.
+    // Server initiated edits break causality, so we avoid those as well.
+    if !world.config.client_caps.code_action_literals {
+        return Ok(None);
+    }
+
+    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();
+    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
 
     let fixes_from_diagnostics = diagnostics
         .into_iter()
@@ -731,26 +732,13 @@ 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 command = Command {
-            title,
-            command: "rust-analyzer.applySourceChange".to_string(),
-            arguments: Some(vec![to_value(edit).unwrap()]),
-        };
-        let action = CodeAction {
-            title: command.title.clone(),
-            kind: None,
-            diagnostics: None,
-            edit: None,
-            command: Some(command),
-            is_preferred: None,
-        };
-        res.push(action.into());
+        let edit = to_proto::snippet_workspace_edit(&world, source_edit)?;
+        let action = lsp_ext::CodeAction { title, kind: None, edit: Some(edit), command: None };
+        res.push(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;
         }
@@ -758,34 +746,41 @@ pub fn handle_code_action(
     }
 
     let mut grouped_assists: FxHashMap<String, (usize, Vec<Assist>)> = FxHashMap::default();
-    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
+    for assist in
+        world.analysis().assists(&world.config.assist, FileRange { file_id, range })?.into_iter()
+    {
         match &assist.group_label {
             Some(label) => grouped_assists
                 .entry(label.to_owned())
                 .or_insert_with(|| {
                     let idx = res.len();
-                    let dummy = Command::new(String::new(), String::new(), None);
-                    res.push(dummy.into());
+                    let dummy = lsp_ext::CodeAction {
+                        title: String::new(),
+                        kind: None,
+                        command: None,
+                        edit: None,
+                    };
+                    res.push(dummy);
                     (idx, Vec::new())
                 })
                 .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 {
@@ -793,121 +788,127 @@ pub fn handle_code_action(
                 command: "rust-analyzer.selectAndApplySourceChange".to_string(),
                 arguments: Some(vec![serde_json::Value::Array(arguments)]),
             });
-            res[idx] = CodeAction {
-                title,
-                kind: None,
-                diagnostics: None,
-                edit: None,
-                command,
-                is_preferred: None,
-            }
-            .into();
+            res[idx] = lsp_ext::CodeAction { title, kind: None, edit: None, command };
         }
     }
 
-    // If the client only supports commands then filter the list
-    // and remove and actions that depend on edits.
-    if !world.config.client_caps.code_action_literals {
-        // FIXME: use drain_filter once it hits stable.
-        res = res
-            .into_iter()
-            .filter_map(|it| match it {
-                cmd @ lsp_types::CodeActionOrCommand::Command(_) => Some(cmd),
-                lsp_types::CodeActionOrCommand::CodeAction(action) => match action.command {
-                    Some(cmd) if action.edit.is_none() => {
-                        Some(lsp_types::CodeActionOrCommand::Command(cmd))
-                    }
-                    _ => None,
-                },
-            })
-            .collect();
-    }
     Ok(Some(res))
 }
 
 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 line_index = world.analysis().file_line_index(file_id)?;
-
     let mut lenses: Vec<CodeLens> = Default::default();
 
-    // Gather runnables
-    for runnable in world.analysis().runnables(file_id)? {
-        let title = match &runnable.kind {
-            RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => "▶️\u{fe0e}Run Test",
-            RunnableKind::Bench { .. } => "Run Bench",
-            RunnableKind::Bin => "Run",
-        }
-        .to_string();
-        let mut r = to_lsp_runnable(&world, file_id, runnable)?;
-        let lens = CodeLens {
-            range: r.range,
-            command: Some(Command {
-                title,
-                command: "rust-analyzer.runSingle".into(),
-                arguments: Some(vec![to_value(&r).unwrap()]),
-            }),
-            data: None,
-        };
-        lenses.push(lens);
-
-        if r.args[0] == "run" {
-            r.args[0] = "build".into();
-        } else {
-            r.args.push("--no-run".into());
-        }
-        let debug_lens = CodeLens {
-            range: r.range,
-            command: Some(Command {
-                title: "Debug".into(),
-                command: "rust-analyzer.debugSingle".into(),
-                arguments: Some(vec![to_value(r).unwrap()]),
-            }),
-            data: None,
-        };
-        lenses.push(debug_lens);
+    if world.config.lens.none() {
+        // early return before any db query!
+        return Ok(Some(lenses));
     }
 
-    // Handle impls
-    lenses.extend(
-        world
-            .analysis()
-            .file_structure(file_id)?
-            .into_iter()
-            .filter(|it| match it.kind {
-                SyntaxKind::TRAIT_DEF | SyntaxKind::STRUCT_DEF | SyntaxKind::ENUM_DEF => true,
-                _ => false,
-            })
-            .map(|it| {
-                let range = it.node_range.conv_with(&line_index);
-                let pos = range.start;
-                let lens_params = req::GotoImplementationParams {
-                    text_document_position_params: req::TextDocumentPositionParams::new(
-                        params.text_document.clone(),
-                        pos,
-                    ),
-                    work_done_progress_params: Default::default(),
-                    partial_result_params: Default::default(),
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
+
+    if world.config.lens.runnable() {
+        // Gather runnables
+        for runnable in world.analysis().runnables(file_id)? {
+            let (run_title, debugee) = match &runnable.kind {
+                RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => {
+                    ("▶\u{fe0e} Run Test", true)
+                }
+                RunnableKind::DocTest { .. } => {
+                    // cargo does not support -no-run for doctests
+                    ("▶\u{fe0e} Run Doctest", false)
+                }
+                RunnableKind::Bench { .. } => {
+                    // Nothing wrong with bench debugging
+                    ("Run Bench", true)
+                }
+                RunnableKind::Bin => {
+                    // Do not suggest binary run on other target than binary
+                    match &cargo_spec {
+                        Some(spec) => match spec.target_kind {
+                            TargetKind::Bin => ("Run", true),
+                            _ => continue,
+                        },
+                        None => continue,
+                    }
+                }
+            };
+
+            let mut r = to_lsp_runnable(&world, file_id, runnable)?;
+            if world.config.lens.run {
+                let lens = CodeLens {
+                    range: r.range,
+                    command: Some(Command {
+                        title: run_title.to_string(),
+                        command: "rust-analyzer.runSingle".into(),
+                        arguments: Some(vec![to_value(&r).unwrap()]),
+                    }),
+                    data: None,
                 };
-                CodeLens {
-                    range,
-                    command: None,
-                    data: Some(to_value(CodeLensResolveData::Impls(lens_params)).unwrap()),
+                lenses.push(lens);
+            }
+
+            if debugee && world.config.lens.debug {
+                if r.args[0] == "run" {
+                    r.args[0] = "build".into();
+                } else {
+                    r.args.push("--no-run".into());
                 }
-            }),
-    );
+                let debug_lens = CodeLens {
+                    range: r.range,
+                    command: Some(Command {
+                        title: "Debug".into(),
+                        command: "rust-analyzer.debugSingle".into(),
+                        arguments: Some(vec![to_value(r).unwrap()]),
+                    }),
+                    data: None,
+                };
+                lenses.push(debug_lens);
+            }
+        }
+    }
 
+    if world.config.lens.impementations {
+        // Handle impls
+        lenses.extend(
+            world
+                .analysis()
+                .file_structure(file_id)?
+                .into_iter()
+                .filter(|it| match it.kind {
+                    SyntaxKind::TRAIT_DEF | SyntaxKind::STRUCT_DEF | SyntaxKind::ENUM_DEF => true,
+                    _ => false,
+                })
+                .map(|it| {
+                    let range = to_proto::range(&line_index, it.node_range);
+                    let pos = range.start;
+                    let lens_params = lsp_types::request::GotoImplementationParams {
+                        text_document_position_params: lsp_types::TextDocumentPositionParams::new(
+                            params.text_document.clone(),
+                            pos,
+                        ),
+                        work_done_progress_params: Default::default(),
+                        partial_result_params: Default::default(),
+                    };
+                    CodeLens {
+                        range,
+                        command: None,
+                        data: Some(to_value(CodeLensResolveData::Impls(lens_params)).unwrap()),
+                    }
+                }),
+        );
+    }
     Ok(Some(lenses))
 }
 
 #[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> {
@@ -918,9 +919,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(),
@@ -957,37 +958,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> {
@@ -998,8 +1001,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,
@@ -1014,18 +1017,22 @@ 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 target = spec.as_ref().map(|s| s.target.clone());
     let (args, extra_args) = CargoTargetSpec::runnable_args(spec, &runnable.kind)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let label = match &runnable.kind {
         RunnableKind::Test { test_id, .. } => format!("test {}", test_id),
         RunnableKind::TestMod { path } => format!("test-mod {}", path),
         RunnableKind::Bench { test_id } => format!("bench {}", test_id),
-        RunnableKind::Bin => "run binary".to_string(),
+        RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id),
+        RunnableKind::Bin => {
+            target.map_or_else(|| "run binary".to_string(), |t| format!("run {}", t))
+        }
     };
-    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,
@@ -1044,13 +1051,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())
 }
 
@@ -1059,21 +1066,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))
 }
@@ -1086,7 +1091,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)? {
@@ -1099,11 +1104,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(),
         });
     }
 
@@ -1118,7 +1126,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)? {
@@ -1131,11 +1139,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(),
         });
     }
 
@@ -1148,26 +1159,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(
@@ -1176,17 +1174,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()))
 }