26 files changed, 454 insertions, 242 deletions

diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index f86f98be7..82e10bc7e 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -75,7 +75,7 @@ pub use crate::{
     runnables::{Runnable, RunnableKind, TestId},
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
     ssr::SsrError,
-    syntax_highlighting::HighlightedRange,
+    syntax_highlighting::{tags, HighlightedRange},
 };
 
 pub use hir::Documentation;
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index d873f153e..812229b4e 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -17,32 +17,32 @@ use crate::{
 };
 
 pub mod tags {
-    pub(crate) const FIELD: &str = "field";
-    pub(crate) const FUNCTION: &str = "function";
-    pub(crate) const MODULE: &str = "module";
-    pub(crate) const CONSTANT: &str = "constant";
-    pub(crate) const MACRO: &str = "macro";
-
-    pub(crate) const VARIABLE: &str = "variable";
-    pub(crate) const VARIABLE_MUT: &str = "variable.mut";
-
-    pub(crate) const TYPE: &str = "type";
-    pub(crate) const TYPE_BUILTIN: &str = "type.builtin";
-    pub(crate) const TYPE_SELF: &str = "type.self";
-    pub(crate) const TYPE_PARAM: &str = "type.param";
-    pub(crate) const TYPE_LIFETIME: &str = "type.lifetime";
-
-    pub(crate) const LITERAL_BYTE: &str = "literal.byte";
-    pub(crate) const LITERAL_NUMERIC: &str = "literal.numeric";
-    pub(crate) const LITERAL_CHAR: &str = "literal.char";
-
-    pub(crate) const LITERAL_COMMENT: &str = "comment";
-    pub(crate) const LITERAL_STRING: &str = "string";
-    pub(crate) const LITERAL_ATTRIBUTE: &str = "attribute";
-
-    pub(crate) const KEYWORD: &str = "keyword";
-    pub(crate) const KEYWORD_UNSAFE: &str = "keyword.unsafe";
-    pub(crate) const KEYWORD_CONTROL: &str = "keyword.control";
+    pub const FIELD: &str = "field";
+    pub const FUNCTION: &str = "function";
+    pub const MODULE: &str = "module";
+    pub const CONSTANT: &str = "constant";
+    pub const MACRO: &str = "macro";
+
+    pub const VARIABLE: &str = "variable";
+    pub const VARIABLE_MUT: &str = "variable.mut";
+
+    pub const TYPE: &str = "type";
+    pub const TYPE_BUILTIN: &str = "type.builtin";
+    pub const TYPE_SELF: &str = "type.self";
+    pub const TYPE_PARAM: &str = "type.param";
+    pub const TYPE_LIFETIME: &str = "type.lifetime";
+
+    pub const LITERAL_BYTE: &str = "literal.byte";
+    pub const LITERAL_NUMERIC: &str = "literal.numeric";
+    pub const LITERAL_CHAR: &str = "literal.char";
+
+    pub const LITERAL_COMMENT: &str = "comment";
+    pub const LITERAL_STRING: &str = "string";
+    pub const LITERAL_ATTRIBUTE: &str = "attribute";
+
+    pub const KEYWORD: &str = "keyword";
+    pub const KEYWORD_UNSAFE: &str = "keyword.unsafe";
+    pub const KEYWORD_CONTROL: &str = "keyword.control";
 }
 
 #[derive(Debug)]
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index c9fd645f1..638987ee8 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -1,12 +1,15 @@
 //! Advertizes the capabilities of the LSP Server.
 
+use crate::semantic_tokens;
+
 use lsp_types::{
     CallHierarchyServerCapability, CodeActionProviderCapability, CodeLensOptions,
     CompletionOptions, DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
     ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
-    SelectionRangeProviderCapability, ServerCapabilities, SignatureHelpOptions,
-    TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
-    TypeDefinitionProviderCapability, WorkDoneProgressOptions,
+    SelectionRangeProviderCapability, SemanticTokensDocumentProvider, SemanticTokensLegend,
+    SemanticTokensOptions, SemanticTokensServerCapabilities, ServerCapabilities,
+    SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind,
+    TextDocumentSyncOptions, TypeDefinitionProviderCapability, WorkDoneProgressOptions,
 };
 
 pub fn server_capabilities() -> ServerCapabilities {
@@ -57,7 +60,20 @@ pub fn server_capabilities() -> ServerCapabilities {
         execute_command_provider: None,
         workspace: None,
         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
-        semantic_tokens_provider: None,
+        semantic_tokens_provider: Some(SemanticTokensServerCapabilities::SemanticTokensOptions(
+            SemanticTokensOptions {
+                legend: SemanticTokensLegend {
+                    token_types: semantic_tokens::supported_token_types().iter().cloned().collect(),
+                    token_modifiers: semantic_tokens::supported_token_modifiers()
+                        .iter()
+                        .cloned()
+                        .collect(),
+                },
+
+                document_provider: Some(SemanticTokensDocumentProvider::Bool(true)),
+                ..SemanticTokensOptions::default()
+            },
+        )),
         experimental: Default::default(),
     }
 }
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index 90ef74056..5fcb46b61 100644
--- a/crates/rust-analyzer/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -4,11 +4,12 @@
 use lsp_types::{
     self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
     Location, LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp,
-    SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
-    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
+    SemanticTokenModifier, SemanticTokenType, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
+    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    WorkspaceEdit,
 };
 use ra_ide::{
-    translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
+    tags, translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
     FileRange, FileSystemEdit, Fold, FoldKind, InsertTextFormat, LineCol, LineIndex,
     NavigationTarget, RangeInfo, ReferenceAccess, Severity, SourceChange, SourceFileEdit,
 };
@@ -16,7 +17,7 @@ use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 use ra_vfs::LineEndings;
 
-use crate::{req, world::WorldSnapshot, Result};
+use crate::{req, semantic_tokens, world::WorldSnapshot, Result};
 
 pub trait Conv {
     type Output;
@@ -302,6 +303,76 @@ impl ConvWith<&FoldConvCtx<'_>> for Fold {
     }
 }
 
+impl Conv for &'static str {
+    type Output = (SemanticTokenType, Vec<SemanticTokenModifier>);
+
+    fn conv(self) -> (SemanticTokenType, Vec<SemanticTokenModifier>) {
+        let token_type: SemanticTokenType = match self {
+            tags::FIELD => SemanticTokenType::MEMBER,
+            tags::FUNCTION => SemanticTokenType::FUNCTION,
+            tags::MODULE => SemanticTokenType::NAMESPACE,
+            tags::CONSTANT => {
+                return (
+                    SemanticTokenType::VARIABLE,
+                    vec![SemanticTokenModifier::STATIC, SemanticTokenModifier::READONLY],
+                )
+            }
+            tags::MACRO => SemanticTokenType::MACRO,
+
+            tags::VARIABLE => {
+                return (SemanticTokenType::VARIABLE, vec![SemanticTokenModifier::READONLY])
+            }
+            tags::VARIABLE_MUT => SemanticTokenType::VARIABLE,
+
+            tags::TYPE => SemanticTokenType::TYPE,
+            tags::TYPE_BUILTIN => SemanticTokenType::TYPE,
+            tags::TYPE_SELF => {
+                return (SemanticTokenType::TYPE, vec![SemanticTokenModifier::REFERENCE])
+            }
+            tags::TYPE_PARAM => SemanticTokenType::TYPE_PARAMETER,
+            tags::TYPE_LIFETIME => {
+                return (SemanticTokenType::LABEL, vec![SemanticTokenModifier::REFERENCE])
+            }
+
+            tags::LITERAL_BYTE => SemanticTokenType::NUMBER,
+            tags::LITERAL_NUMERIC => SemanticTokenType::NUMBER,
+            tags::LITERAL_CHAR => SemanticTokenType::NUMBER,
+
+            tags::LITERAL_COMMENT => {
+                return (SemanticTokenType::COMMENT, vec![SemanticTokenModifier::DOCUMENTATION])
+            }
+
+            tags::LITERAL_STRING => SemanticTokenType::STRING,
+            tags::LITERAL_ATTRIBUTE => SemanticTokenType::KEYWORD,
+
+            tags::KEYWORD => SemanticTokenType::KEYWORD,
+            tags::KEYWORD_UNSAFE => SemanticTokenType::KEYWORD,
+            tags::KEYWORD_CONTROL => SemanticTokenType::KEYWORD,
+            unknown => panic!("Unknown semantic token: {}", unknown),
+        };
+
+        (token_type, vec![])
+    }
+}
+
+impl Conv for (SemanticTokenType, Vec<SemanticTokenModifier>) {
+    type Output = (u32, u32);
+
+    fn conv(self) -> Self::Output {
+        let token_index =
+            semantic_tokens::supported_token_types().iter().position(|it| *it == self.0).unwrap();
+        let mut token_modifier_bitset = 0;
+        for modifier in self.1.iter() {
+            token_modifier_bitset |= semantic_tokens::supported_token_modifiers()
+                .iter()
+                .position(|it| it == modifier)
+                .unwrap();
+        }
+
+        (token_index as u32, token_modifier_bitset as u32)
+    }
+}
+
 impl<T: ConvWith<CTX>, CTX> ConvWith<CTX> for Option<T> {
     type Output = Option<T::Output>;
 
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 0dae30e46..a0f968823 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -36,6 +36,7 @@ pub mod req;
 mod config;
 mod world;
 mod diagnostics;
+mod semantic_tokens;
 
 use serde::de::DeserializeOwned;
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 98306986b..6e9e604a6 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -528,6 +528,7 @@ fn on_request(
         .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
         .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
         .on::<req::Ssr>(handlers::handle_ssr)?
+        .on::<req::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
         .finish();
     Ok(())
 }
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index bb7bab372..e13e7c95a 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -16,8 +16,9 @@ use lsp_types::{
     CodeAction, CodeActionOrCommand, CodeActionResponse, CodeLens, Command, CompletionItem,
     Diagnostic, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
     FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
-    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
-    TextEdit, WorkspaceEdit,
+    PrepareRenameResponse, Range, RenameParams, SemanticTokenModifier, SemanticTokenType,
+    SemanticTokens, SemanticTokensParams, SemanticTokensResult, SymbolInformation,
+    TextDocumentIdentifier, TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
     AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
@@ -38,6 +39,7 @@ use crate::{
     diagnostics::DiagnosticTask,
     from_json,
     req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
+    semantic_tokens::SemanticTokensBuilder,
     world::WorldSnapshot,
     LspError, Result,
 };
@@ -1068,3 +1070,25 @@ pub fn handle_call_hierarchy_outgoing(
 
     Ok(Some(res))
 }
+
+pub fn handle_semantic_tokens(
+    world: WorldSnapshot,
+    params: SemanticTokensParams,
+) -> Result<Option<SemanticTokensResult>> {
+    let _p = profile("handle_semantic_tokens");
+
+    let file_id = params.text_document.try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+
+    let mut builder = SemanticTokensBuilder::default();
+
+    for h in world.analysis().highlight(file_id)?.into_iter() {
+        let type_and_modifiers: (SemanticTokenType, Vec<SemanticTokenModifier>) = h.tag.conv();
+        let (token_type, token_modifiers) = type_and_modifiers.conv();
+        builder.push(h.range.conv_with(&line_index), token_type, token_modifiers);
+    }
+
+    let tokens = SemanticTokens { data: builder.build(), ..Default::default() };
+
+    Ok(Some(tokens.into()))
+}
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index 7ff7f60b3..3734899bc 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -12,9 +12,9 @@ pub use lsp_types::{
     DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
     PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,
     PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams, SelectionRange,
-    SelectionRangeParams, ServerCapabilities, ShowMessageParams, SignatureHelp, SymbolKind,
-    TextDocumentEdit, TextDocumentPositionParams, TextEdit, WorkDoneProgressParams, WorkspaceEdit,
-    WorkspaceSymbolParams,
+    SelectionRangeParams, SemanticTokensParams, SemanticTokensResult, ServerCapabilities,
+    ShowMessageParams, SignatureHelp, SymbolKind, TextDocumentEdit, TextDocumentPositionParams,
+    TextEdit, WorkDoneProgressParams, WorkspaceEdit, WorkspaceSymbolParams,
 };
 
 pub enum AnalyzerStatus {}
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
new file mode 100644
index 000000000..ad000a3ce
--- /dev/null
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -0,0 +1,94 @@
+//! Semantic Tokens helpers
+
+use lsp_types::{Range, SemanticToken, SemanticTokenModifier, SemanticTokenType};
+
+const SUPPORTED_TYPES: &[SemanticTokenType] = &[
+    SemanticTokenType::COMMENT,
+    SemanticTokenType::KEYWORD,
+    SemanticTokenType::STRING,
+    SemanticTokenType::NUMBER,
+    SemanticTokenType::REGEXP,
+    SemanticTokenType::OPERATOR,
+    SemanticTokenType::NAMESPACE,
+    SemanticTokenType::TYPE,
+    SemanticTokenType::STRUCT,
+    SemanticTokenType::CLASS,
+    SemanticTokenType::INTERFACE,
+    SemanticTokenType::ENUM,
+    SemanticTokenType::TYPE_PARAMETER,
+    SemanticTokenType::FUNCTION,
+    SemanticTokenType::MEMBER,
+    SemanticTokenType::PROPERTY,
+    SemanticTokenType::MACRO,
+    SemanticTokenType::VARIABLE,
+    SemanticTokenType::PARAMETER,
+    SemanticTokenType::LABEL,
+];
+
+const SUPPORTED_MODIFIERS: &[SemanticTokenModifier] = &[
+    SemanticTokenModifier::DOCUMENTATION,
+    SemanticTokenModifier::DECLARATION,
+    SemanticTokenModifier::DEFINITION,
+    SemanticTokenModifier::REFERENCE,
+    SemanticTokenModifier::STATIC,
+    SemanticTokenModifier::ABSTRACT,
+    SemanticTokenModifier::DEPRECATED,
+    SemanticTokenModifier::ASYNC,
+    SemanticTokenModifier::VOLATILE,
+    SemanticTokenModifier::READONLY,
+];
+
+/// Token types that the server supports
+pub(crate) fn supported_token_types() -> &'static [SemanticTokenType] {
+    SUPPORTED_TYPES
+}
+
+/// Token modifiers that the server supports
+pub(crate) fn supported_token_modifiers() -> &'static [SemanticTokenModifier] {
+    SUPPORTED_MODIFIERS
+}
+
+/// Tokens are encoded relative to each other.
+/// 
+/// This is a direct port of https://github.com/microsoft/vscode-languageserver-node/blob/f425af9de46a0187adb78ec8a46b9b2ce80c5412/server/src/sematicTokens.proposed.ts#L45
+#[derive(Default)]
+pub(crate) struct SemanticTokensBuilder {
+    prev_line: u32,
+    prev_char: u32,
+    data: Vec<SemanticToken>,
+}
+
+impl SemanticTokensBuilder {
+    /// Push a new token onto the builder
+    pub fn push(&mut self, range: Range, token_index: u32, modifier_bitset: u32) {
+        let mut push_line = range.start.line as u32;
+        let mut push_char = range.start.character as u32;
+
+        if !self.data.is_empty() {
+            push_line -= self.prev_line;
+            if push_line == 0 {
+                push_char -= self.prev_char;
+            }
+        }
+
+        // A token cannot be multiline
+        let token_len = range.end.character - range.start.character;
+
+        let token = SemanticToken {
+            delta_line: push_line,
+            delta_start: push_char,
+            length: token_len as u32,
+            token_type: token_index,
+            token_modifiers_bitset: modifier_bitset,
+        };
+
+        self.data.push(token);
+
+        self.prev_line = range.start.line as u32;
+        self.prev_char = range.start.character as u32;
+    }
+
+    pub fn build(self) -> Vec<SemanticToken> {
+        self.data
+    }
+}
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 76ef2aae4..0288a468e 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -1575,9 +1575,9 @@
             }
         },
         "typescript": {
-            "version": "3.7.5",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz",
-            "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==",
+            "version": "3.8.2",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.8.2.tgz",
+            "integrity": "sha512-EgOVgL/4xfVrCMbhYKUQTdF37SQn4Iw73H5BgCrF1Abdun7Kwy/QZsE/ssAy0y4LxBbvua3PIbFsbRczWWnDdQ==",
             "dev": true
         },
         "typescript-formatter": {
diff --git a/editors/code/package.json b/editors/code/package.json
index 9ef6c6983..dff535fcd 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -42,7 +42,7 @@
         "eslint": "^6.8.0",
         "rollup": "^1.31.1",
         "tslib": "^1.10.0",
-        "typescript": "^3.7.5",
+        "typescript": "^3.8.2",
         "typescript-formatter": "^7.2.2",
         "vsce": "^1.73.0"
     },
diff --git a/editors/code/src/commands/analyzer_status.ts b/editors/code/src/commands/analyzer_status.ts
index 6631e8db7..1c6ea399b 100644
--- a/editors/code/src/commands/analyzer_status.ts
+++ b/editors/code/src/commands/analyzer_status.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 
+import * as ra from '../rust-analyzer-api';
 import { Ctx, Cmd } from '../ctx';
 
 // Shows status of rust-analyzer (for debugging)
@@ -50,10 +51,7 @@ class TextDocumentContentProvider
         const client = this.ctx.client;
         if (!editor || !client) return '';
 
-        return client.sendRequest<string>(
-            'rust-analyzer/analyzerStatus',
-            null,
-        );
+        return client.sendRequest(ra.analyzerStatus, null);
     }
 
     get onDidChange(): vscode.Event<vscode.Uri> {
diff --git a/editors/code/src/commands/expand_macro.ts b/editors/code/src/commands/expand_macro.ts
index edec9bbc1..23f2ef1d5 100644
--- a/editors/code/src/commands/expand_macro.ts
+++ b/editors/code/src/commands/expand_macro.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 
@@ -26,12 +26,7 @@ export function expandMacro(ctx: Ctx): Cmd {
     };
 }
 
-interface ExpandedMacro {
-    name: string;
-    expansion: string;
-}
-
-function codeFormat(expanded: ExpandedMacro): string {
+function codeFormat(expanded: ra.ExpandedMacro): string {
     let result = `// Recursive expansion of ${expanded.name}! macro\n`;
     result += '// ' + '='.repeat(result.length - 3);
     result += '\n\n';
@@ -54,14 +49,11 @@ class TextDocumentContentProvider
         if (!editor || !client) return '';
 
         const position = editor.selection.active;
-        const request: lc.TextDocumentPositionParams = {
+
+        const expanded = await client.sendRequest(ra.expandMacro, {
             textDocument: { uri: editor.document.uri.toString() },
             position,
-        };
-        const expanded = await client.sendRequest<ExpandedMacro>(
-            'rust-analyzer/expandMacro',
-            request,
-        );
+        });
 
         if (expanded == null) return 'Not available';
 
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
index 839245f48..bdb7fc3b0 100644
--- a/editors/code/src/commands/index.ts
+++ b/editors/code/src/commands/index.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 import * as sourceChange from '../source_change';
@@ -16,9 +17,7 @@ export * from './ssr';
 export * from './server_version';
 
 export function collectGarbage(ctx: Ctx): Cmd {
-    return async () => {
-        await ctx.client?.sendRequest<null>('rust-analyzer/collectGarbage', null);
-    };
+    return async () => ctx.client.sendRequest(ra.collectGarbage, null);
 }
 
 export function showReferences(ctx: Ctx): Cmd {
@@ -36,13 +35,13 @@ export function showReferences(ctx: Ctx): Cmd {
 }
 
 export function applySourceChange(ctx: Ctx): Cmd {
-    return async (change: sourceChange.SourceChange) => {
+    return async (change: ra.SourceChange) => {
         await sourceChange.applySourceChange(ctx, change);
     };
 }
 
 export function selectAndApplySourceChange(ctx: Ctx): Cmd {
-    return async (changes: sourceChange.SourceChange[]) => {
+    return async (changes: ra.SourceChange[]) => {
         if (changes.length === 1) {
             await sourceChange.applySourceChange(ctx, changes[0]);
         } else if (changes.length > 0) {
diff --git a/editors/code/src/commands/join_lines.ts b/editors/code/src/commands/join_lines.ts
index 7b08c3255..de0614653 100644
--- a/editors/code/src/commands/join_lines.ts
+++ b/editors/code/src/commands/join_lines.ts
@@ -1,7 +1,7 @@
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
-import { applySourceChange, SourceChange } from '../source_change';
+import { applySourceChange } from '../source_change';
 
 export function joinLines(ctx: Ctx): Cmd {
     return async () => {
@@ -9,19 +9,10 @@ export function joinLines(ctx: Ctx): Cmd {
         const client = ctx.client;
         if (!editor || !client) return;
 
-        const request: JoinLinesParams = {
+        const change = await client.sendRequest(ra.joinLines, {
             range: client.code2ProtocolConverter.asRange(editor.selection),
             textDocument: { uri: editor.document.uri.toString() },
-        };
-        const change = await client.sendRequest<SourceChange>(
-            'rust-analyzer/joinLines',
-            request,
-        );
+        });
         await applySourceChange(ctx, change);
     };
 }
-
-interface JoinLinesParams {
-    textDocument: lc.TextDocumentIdentifier;
-    range: lc.Range;
-}
diff --git a/editors/code/src/commands/matching_brace.ts b/editors/code/src/commands/matching_brace.ts
index 7c58bb7e7..a60776e2d 100644
--- a/editors/code/src/commands/matching_brace.ts
+++ b/editors/code/src/commands/matching_brace.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 
@@ -9,16 +9,12 @@ export function matchingBrace(ctx: Ctx): Cmd {
         const client = ctx.client;
         if (!editor || !client) return;
 
-        const request: FindMatchingBraceParams = {
+        const response = await client.sendRequest(ra.findMatchingBrace, {
             textDocument: { uri: editor.document.uri.toString() },
             offsets: editor.selections.map(s =>
                 client.code2ProtocolConverter.asPosition(s.active),
             ),
-        };
-        const response = await client.sendRequest<lc.Position[]>(
-            'rust-analyzer/findMatchingBrace',
-            request,
-        );
+        });
         editor.selections = editor.selections.map((sel, idx) => {
             const active = client.protocol2CodeConverter.asPosition(
                 response[idx],
@@ -29,8 +25,3 @@ export function matchingBrace(ctx: Ctx): Cmd {
         editor.revealRange(editor.selection);
     };
 }
-
-interface FindMatchingBraceParams {
-    textDocument: lc.TextDocumentIdentifier;
-    offsets: lc.Position[];
-}
diff --git a/editors/code/src/commands/on_enter.ts b/editors/code/src/commands/on_enter.ts
index 27ae8ec23..285849db7 100644
--- a/editors/code/src/commands/on_enter.ts
+++ b/editors/code/src/commands/on_enter.ts
@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
-import { applySourceChange, SourceChange } from '../source_change';
+import { applySourceChange } from '../source_change';
 import { Cmd, Ctx } from '../ctx';
 
 async function handleKeypress(ctx: Ctx) {
@@ -10,22 +10,15 @@ async function handleKeypress(ctx: Ctx) {
 
     if (!editor || !client) return false;
 
-    const request: lc.TextDocumentPositionParams = {
+    const change = await client.sendRequest(ra.onEnter, {
         textDocument: { uri: editor.document.uri.toString() },
         position: client.code2ProtocolConverter.asPosition(
             editor.selection.active,
         ),
-    };
-    const change = await client.sendRequest<undefined | SourceChange>(
-        'rust-analyzer/onEnter',
-        request,
-    ).catch(
-        (_error: any) => {
-            // FIXME: switch to the more modern (?) typed request infrastructure
-            // client.logFailedRequest(OnEnterRequest.type, error);
-            return Promise.resolve(null);
-        }
-    );
+    }).catch(_error => {
+        // client.logFailedRequest(OnEnterRequest.type, error);
+        return null;
+    });
     if (!change) return false;
 
     await applySourceChange(ctx, change);
diff --git a/editors/code/src/commands/parent_module.ts b/editors/code/src/commands/parent_module.ts
index bf40b4021..8f78ddd71 100644
--- a/editors/code/src/commands/parent_module.ts
+++ b/editors/code/src/commands/parent_module.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 
@@ -9,16 +9,12 @@ export function parentModule(ctx: Ctx): Cmd {
         const client = ctx.client;
         if (!editor || !client) return;
 
-        const request: lc.TextDocumentPositionParams = {
+        const response = await client.sendRequest(ra.parentModule, {
             textDocument: { uri: editor.document.uri.toString() },
             position: client.code2ProtocolConverter.asPosition(
                 editor.selection.active,
             ),
-        };
-        const response = await client.sendRequest<lc.Location[]>(
-            'rust-analyzer/parentModule',
-            request,
-        );
+        });
         const loc = response[0];
         if (loc == null) return;
 
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 7919997ce..06b513466 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 
@@ -14,16 +15,13 @@ export function run(ctx: Ctx): Cmd {
         const textDocument: lc.TextDocumentIdentifier = {
             uri: editor.document.uri.toString(),
         };
-        const params: RunnablesParams = {
+
+        const runnables = await client.sendRequest(ra.runnables, {
             textDocument,
             position: client.code2ProtocolConverter.asPosition(
                 editor.selection.active,
             ),
-        };
-        const runnables = await client.sendRequest<Runnable[]>(
-            'rust-analyzer/runnables',
-            params,
-        );
+        });
         const items: RunnableQuickPick[] = [];
         if (prevRunnable) {
             items.push(prevRunnable);
@@ -48,7 +46,7 @@ export function run(ctx: Ctx): Cmd {
 }
 
 export function runSingle(ctx: Ctx): Cmd {
-    return async (runnable: Runnable) => {
+    return async (runnable: ra.Runnable) => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
 
@@ -64,26 +62,13 @@ export function runSingle(ctx: Ctx): Cmd {
     };
 }
 
-interface RunnablesParams {
-    textDocument: lc.TextDocumentIdentifier;
-    position?: lc.Position;
-}
-
-interface Runnable {
-    label: string;
-    bin: string;
-    args: string[];
-    env: { [index: string]: string };
-    cwd?: string;
-}
-
 class RunnableQuickPick implements vscode.QuickPickItem {
     public label: string;
     public description?: string | undefined;
     public detail?: string | undefined;
     public picked?: boolean | undefined;
 
-    constructor(public runnable: Runnable) {
+    constructor(public runnable: ra.Runnable) {
         this.label = runnable.label;
     }
 }
@@ -96,7 +81,7 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
     env?: { [key: string]: string };
 }
 
-function createTask(spec: Runnable): vscode.Task {
+function createTask(spec: ra.Runnable): vscode.Task {
     const TASK_SOURCE = 'Rust';
     const definition: CargoTaskDefinition = {
         type: 'cargo',
diff --git a/editors/code/src/commands/ssr.ts b/editors/code/src/commands/ssr.ts
index 9b814612a..eee48c693 100644
--- a/editors/code/src/commands/ssr.ts
+++ b/editors/code/src/commands/ssr.ts
@@ -1,6 +1,8 @@
-import { Ctx, Cmd } from '../ctx';
-import { applySourceChange, SourceChange } from '../source_change';
 import * as vscode from 'vscode';
+import * as ra from "../rust-analyzer-api";
+
+import { Ctx, Cmd } from '../ctx';
+import { applySourceChange } from '../source_change';
 
 export function ssr(ctx: Ctx): Cmd {
     return async () => {
@@ -21,16 +23,8 @@ export function ssr(ctx: Ctx): Cmd {
 
         if (!request) return;
 
-        const ssrRequest: SsrRequest = { arg: request };
-        const change = await client.sendRequest<SourceChange>(
-            'rust-analyzer/ssr',
-            ssrRequest,
-        );
+        const change = await client.sendRequest(ra.ssr, { arg: request });
 
         await applySourceChange(ctx, change);
     };
 }
-
-interface SsrRequest {
-    arg: string;
-}
diff --git a/editors/code/src/commands/syntax_tree.ts b/editors/code/src/commands/syntax_tree.ts
index 2887c96c8..7218bfb90 100644
--- a/editors/code/src/commands/syntax_tree.ts
+++ b/editors/code/src/commands/syntax_tree.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from '../rust-analyzer-api';
 
 import { Ctx, Cmd } from '../ctx';
 
@@ -61,13 +61,8 @@ function afterLs(f: () => void) {
     setTimeout(f, 10);
 }
 
-interface SyntaxTreeParams {
-    textDocument: lc.TextDocumentIdentifier;
-    range?: lc.Range;
-}
 
-class TextDocumentContentProvider
-    implements vscode.TextDocumentContentProvider {
+class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
     uri = vscode.Uri.parse('rust-analyzer://syntaxtree');
     eventEmitter = new vscode.EventEmitter<vscode.Uri>();
 
@@ -79,23 +74,15 @@ class TextDocumentContentProvider
         const client = this.ctx.client;
         if (!editor || !client) return '';
 
-        let range: lc.Range | undefined;
-
         // When the range based query is enabled we take the range of the selection
-        if (uri.query === 'range=true') {
-            range = editor.selection.isEmpty
-                ? undefined
-                : client.code2ProtocolConverter.asRange(editor.selection);
-        }
+        const range = uri.query === 'range=true' && !editor.selection.isEmpty
+            ? client.code2ProtocolConverter.asRange(editor.selection)
+            : null;
 
-        const request: SyntaxTreeParams = {
+        return client.sendRequest(ra.syntaxTree, {
             textDocument: { uri: editor.document.uri.toString() },
             range,
-        };
-        return client.sendRequest<string>(
-            'rust-analyzer/syntaxTree',
-            request,
-        );
+        });
     }
 
     get onDidChange(): vscode.Event<vscode.Uri> {
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
index 77b4a1a68..3e0cbdc56 100644
--- a/editors/code/src/highlighting.ts
+++ b/editors/code/src/highlighting.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 
 import { ColorTheme, TextMateRuleSettings } from './color_theme';
 
@@ -8,29 +8,25 @@ import { sendRequestWithRetry } from './util';
 
 export function activateHighlighting(ctx: Ctx) {
     const highlighter = new Highlighter(ctx);
-    const client = ctx.client;
-    if (client != null) {
-        client.onNotification(
-            'rust-analyzer/publishDecorations',
-            (params: PublishDecorationsParams) => {
-                if (!ctx.config.highlightingOn) return;
-
-                const targetEditor = vscode.window.visibleTextEditors.find(
-                    editor => {
-                        const unescapedUri = unescape(
-                            editor.document.uri.toString(),
-                        );
-                        // Unescaped URI looks like:
-                        // file:///c:/Workspace/ra-test/src/main.rs
-                        return unescapedUri === params.uri;
-                    },
-                );
-                if (!targetEditor) return;
 
-                highlighter.setHighlights(targetEditor, params.decorations);
+    ctx.client.onNotification(ra.publishDecorations, params => {
+        if (!ctx.config.highlightingOn) return;
+
+        const targetEditor = vscode.window.visibleTextEditors.find(
+            editor => {
+                const unescapedUri = unescape(
+                    editor.document.uri.toString(),
+                );
+                // Unescaped URI looks like:
+                // file:///c:/Workspace/ra-test/src/main.rs
+                return unescapedUri === params.uri;
             },
         );
-    }
+        if (!targetEditor) return;
+
+        highlighter.setHighlights(targetEditor, params.decorations);
+    });
+
 
     vscode.workspace.onDidChangeConfiguration(
         _ => highlighter.removeHighlights(),
@@ -45,13 +41,10 @@ export function activateHighlighting(ctx: Ctx) {
             const client = ctx.client;
             if (!client) return;
 
-            const params: lc.TextDocumentIdentifier = {
-                uri: editor.document.uri.toString(),
-            };
-            const decorations = await sendRequestWithRetry<Decoration[]>(
+            const decorations = await sendRequestWithRetry(
                 client,
-                'rust-analyzer/decorationsRequest',
-                params,
+                ra.decorationsRequest,
+                { uri: editor.document.uri.toString() },
             );
             highlighter.setHighlights(editor, decorations);
         },
@@ -60,17 +53,6 @@ export function activateHighlighting(ctx: Ctx) {
     );
 }
 
-interface PublishDecorationsParams {
-    uri: string;
-    decorations: Decoration[];
-}
-
-interface Decoration {
-    range: lc.Range;
-    tag: string;
-    bindingHash?: string;
-}
-
 // Based on this HSL-based color generator: https://gist.github.com/bendc/76c48ce53299e6078a76
 function fancify(seed: string, shade: 'light' | 'dark') {
     const random = randomU32Numbers(hashString(seed));
@@ -108,7 +90,7 @@ class Highlighter {
         this.decorations = null;
     }
 
-    public setHighlights(editor: vscode.TextEditor, highlights: Decoration[]) {
+    public setHighlights(editor: vscode.TextEditor, highlights: ra.Decoration[]) {
         const client = this.ctx.client;
         if (!client) return;
         // Initialize decorations if necessary
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 5f9229efb..5951cf1b4 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 
 import { Ctx } from './ctx';
 import { log, sendRequestWithRetry } from './util';
@@ -39,16 +39,6 @@ export function activateInlayHints(ctx: Ctx) {
     void hintsUpdater.setEnabled(ctx.config.displayInlayHints);
 }
 
-interface InlayHintsParams {
-    textDocument: lc.TextDocumentIdentifier;
-}
-
-interface InlayHint {
-    range: vscode.Range;
-    kind: "TypeHint" | "ParameterHint";
-    label: string;
-}
-
 const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
     after: {
         color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
@@ -107,9 +97,9 @@ class HintsUpdater {
         if (newHints == null) return;
 
         const newTypeDecorations = newHints
-            .filter(hint => hint.kind === 'TypeHint')
+            .filter(hint => hint.kind === ra.InlayKind.TypeHint)
             .map(hint => ({
-                range: hint.range,
+                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
                 renderOptions: {
                     after: {
                         contentText: `: ${hint.label}`,
@@ -119,9 +109,9 @@ class HintsUpdater {
         this.setTypeDecorations(editor, newTypeDecorations);
 
         const newParameterDecorations = newHints
-            .filter(hint => hint.kind === 'ParameterHint')
+            .filter(hint => hint.kind === ra.InlayKind.ParameterHint)
             .map(hint => ({
-                range: hint.range,
+                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
                 renderOptions: {
                     before: {
                         contentText: `${hint.label}: `,
@@ -151,20 +141,15 @@ class HintsUpdater {
         );
     }
 
-    private async queryHints(documentUri: string): Promise<InlayHint[] | null> {
+    private async queryHints(documentUri: string): Promise<ra.InlayHint[] | null> {
         this.pending.get(documentUri)?.cancel();
 
         const tokenSource = new vscode.CancellationTokenSource();
         this.pending.set(documentUri, tokenSource);
 
-        const request: InlayHintsParams = { textDocument: { uri: documentUri } };
+        const request = { textDocument: { uri: documentUri } };
 
-        return sendRequestWithRetry<InlayHint[]>(
-            this.ctx.client,
-            'rust-analyzer/inlayHints',
-            request,
-            tokenSource.token
-        )
+        return sendRequestWithRetry(this.ctx.client, ra.inlayHints, request, tokenSource.token)
             .catch(_ => null)
             .finally(() => {
                 if (!tokenSource.token.isCancellationRequested) {
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
new file mode 100644
index 000000000..c5a010e94
--- /dev/null
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -0,0 +1,117 @@
+/**
+ * This file mirrors `crates/rust-analyzer/src/req.rs` declarations.
+ */
+
+import * as lc from "vscode-languageclient";
+
+type Option<T> = null | T;
+type Vec<T> = T[];
+type FxHashMap<K extends PropertyKey, V> = Record<K, V>;
+
+function request<TParams, TResult>(method: string) {
+    return new lc.RequestType<TParams, TResult, unknown>(`rust-analyzer/${method}`);
+}
+function notification<TParam>(method: string) {
+    return new lc.NotificationType<TParam>(method);
+}
+
+
+export const analyzerStatus = request<null, string>("analyzerStatus");
+
+
+export const collectGarbage = request<null, null>("collectGarbage");
+
+
+export interface SyntaxTreeParams {
+    textDocument: lc.TextDocumentIdentifier;
+    range: Option<lc.Range>;
+}
+export const syntaxTree = request<SyntaxTreeParams, string>("syntaxTree");
+
+
+export interface ExpandMacroParams {
+    textDocument: lc.TextDocumentIdentifier;
+    position: Option<lc.Position>;
+}
+export interface ExpandedMacro {
+    name: string;
+    expansion: string;
+}
+export const expandMacro = request<ExpandMacroParams, Option<ExpandedMacro>>("expandMacro");
+
+
+export interface FindMatchingBraceParams {
+    textDocument: lc.TextDocumentIdentifier;
+    offsets: Vec<lc.Position>;
+}
+export const findMatchingBrace = request<FindMatchingBraceParams, Vec<lc.Position>>("findMatchingBrace");
+
+
+export interface PublishDecorationsParams {
+    uri: string;
+    decorations: Vec<Decoration>;
+}
+export interface Decoration {
+    range: lc.Range;
+    tag: string;
+    bindingHash: Option<string>;
+}
+export const decorationsRequest = request<lc.TextDocumentIdentifier, Vec<Decoration>>("decorationsRequest");
+
+
+export const parentModule = request<lc.TextDocumentPositionParams, Vec<lc.Location>>("parentModule");
+
+
+export interface JoinLinesParams {
+    textDocument: lc.TextDocumentIdentifier;
+    range: lc.Range;
+}
+export const joinLines = request<JoinLinesParams, SourceChange>("joinLines");
+
+
+export const onEnter = request<lc.TextDocumentPositionParams, Option<SourceChange>>("onEnter");
+
+export interface RunnablesParams {
+    textDocument: lc.TextDocumentIdentifier;
+    position: Option<lc.Position>;
+}
+export interface Runnable {
+    range: lc.Range;
+    label: string;
+    bin: string;
+    args: Vec<string>;
+    env: FxHashMap<string, string>;
+    cwd: Option<string>;
+}
+export const runnables = request<RunnablesParams, Vec<Runnable>>("runnables");
+
+
+export const enum InlayKind {
+    TypeHint = "TypeHint",
+    ParameterHint = "ParameterHint",
+}
+export interface InlayHint {
+    range: lc.Range;
+    kind: InlayKind;
+    label: string;
+}
+export interface InlayHintsParams {
+    textDocument: lc.TextDocumentIdentifier;
+}
+export const inlayHints = request<InlayHintsParams, Vec<InlayHint>>("inlayHints");
+
+
+export interface SsrParams {
+    arg: string;
+}
+export const ssr = request<SsrParams, SourceChange>("ssr");
+
+
+export const publishDecorations = notification<PublishDecorationsParams>("publishDecorations");
+
+
+export interface SourceChange {
+    label: string;
+    workspaceEdit: lc.WorkspaceEdit;
+    cursorPosition: Option<lc.TextDocumentPositionParams>;
+}
diff --git a/editors/code/src/source_change.ts b/editors/code/src/source_change.ts
index a336269ba..399a150c6 100644
--- a/editors/code/src/source_change.ts
+++ b/editors/code/src/source_change.ts
@@ -1,15 +1,10 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as ra from './rust-analyzer-api';
 
 import { Ctx } from './ctx';
 
-export interface SourceChange {
-    label: string;
-    workspaceEdit: lc.WorkspaceEdit;
-    cursorPosition?: lc.TextDocumentPositionParams;
-}
-
-export async function applySourceChange(ctx: Ctx, change: SourceChange) {
+export async function applySourceChange(ctx: Ctx, change: ra.SourceChange) {
     const client = ctx.client;
     if (!client) return;
 
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 2f18f85a3..68c2a94d0 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -20,21 +20,21 @@ export const log = {
     }
 };
 
-export async function sendRequestWithRetry<R>(
+export async function sendRequestWithRetry<TParam, TRet>(
     client: lc.LanguageClient,
-    method: string,
-    param: unknown,
+    reqType: lc.RequestType<TParam, TRet, unknown>,
+    param: TParam,
     token?: vscode.CancellationToken,
-): Promise<R> {
+): Promise<TRet> {
     for (const delay of [2, 4, 6, 8, 10, null]) {
         try {
             return await (token
-                ? client.sendRequest(method, param, token)
-                : client.sendRequest(method, param)
+                ? client.sendRequest(reqType, param, token)
+                : client.sendRequest(reqType, param)
             );
         } catch (error) {
             if (delay === null) {
-                log.error("LSP request timed out", { method, param, error });
+                log.error("LSP request timed out", { method: reqType.method, param, error });
                 throw error;
             }
 
@@ -43,7 +43,7 @@ export async function sendRequestWithRetry<R>(
             }
 
             if (error.code !== lc.ErrorCodes.ContentModified) {
-                log.error("LSP request failed", { method, param, error });
+                log.error("LSP request failed", { method: reqType.method, param, error });
                 throw error;
             }