22 files changed, 839 insertions, 239 deletions
diff --git a/.travis.yml b/.travis.yml
index 940435172..c6e22d765 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,12 +1,13 @@
 cache: cargo
 before_cache:
-    - find ./target/debug -type f -maxdepth 1 -delete
+    - find ./target/debug -maxdepth 1 -type f -delete
    - rm -fr ./target/debug/{deps,.fingerprint}/{*ra_*,*test*,*tools*,*gen_lsp*,*thread_worker*}
    - rm -f  ./target/.rustc_info.json
 matrix:
    include:
        - os: linux
+          dist: xenial
          language: rust
          rust: stable
          script:
diff --git a/Cargo.lock b/Cargo.lock
index 5aa4ff5de..9502fed45 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -491,6 +491,7 @@ version = "0.2.0"
 dependencies = [
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "flexi_logger 0.11.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lsp-types 0.57.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.91 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1089,6 +1090,7 @@ version = "0.1.0"
 dependencies = [
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_arena 0.1.0",
+ "ra_prof 0.1.0",
 "ra_syntax 0.1.0",
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index ba8bfdbd3..fa2fefea5 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -14,3 +14,6 @@ failure = "0.1.4"
 serde_json = "1.0.34"
 serde = { version = "1.0.83", features = ["derive"] }
 crossbeam-channel = "0.3.5"
+[dev-dependencies]
+flexi_logger = "0.11.0"
diff --git a/crates/gen_lsp_server/examples/01_gen_lsp_server.rs b/crates/gen_lsp_server/examples/01_gen_lsp_server.rs
new file mode 100644
index 000000000..60c581075
--- /dev/null
+++ b/crates/gen_lsp_server/examples/01_gen_lsp_server.rs
@@ -0,0 +1,45 @@
+use crossbeam_channel::{Sender, Receiver};
+use lsp_types::{
+    ServerCapabilities, InitializeParams,
+    request::{GotoDefinition, GotoDefinitionResponse},
+};
+use gen_lsp_server::{run_server, stdio_transport, handle_shutdown, RawMessage, RawResponse};
+fn main() -> Result<(), failure::Error> {
+    let (receiver, sender, io_threads) = stdio_transport();
+    run_server(ServerCapabilities::default(), receiver, sender, main_loop)?;
+    io_threads.join()?;
+    Ok(())
+}
+fn main_loop(
+    _params: InitializeParams,
+    receiver: &Receiver<RawMessage>,
+    sender: &Sender<RawMessage>,
+) -> Result<(), failure::Error> {
+    for msg in receiver {
+        match msg {
+            RawMessage::Request(req) => {
+                let req = match handle_shutdown(req, sender) {
+                    None => return Ok(()),
+                    Some(req) => req,
+                };
+                match req.cast::<GotoDefinition>() {
+                    Ok((id, _params)) => {
+                        let resp = RawResponse::ok::<GotoDefinition>(
+                            id,
+                            &Some(GotoDefinitionResponse::Array(Vec::new())),
+                        );
+                        sender.send(RawMessage::Response(resp))?;
+                        continue;
+                    }
+                    Err(req) => req,
+                };
+                // ...
+            }
+            RawMessage::Response(_resp) => (),
+            RawMessage::Notification(_not) => (),
+        }
+    }
+    Ok(())
+}
diff --git a/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs
new file mode 100644
index 000000000..27e4f1cbc
--- /dev/null
+++ b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs
@@ -0,0 +1,118 @@
+//! A minimal example LSP server that can only respond to the `gotoDefinition` request. To use
+//! this example, execute it and then send an `initialize` request.
+//!
+//! ```no_run
+//! Content-Length: 85
+//!
+//! {"jsonrpc": "2.0", "method": "initialize", "id": 1, "params": {"capabilities": {}}}
+//! ```
+//!
+//! This will respond with a server respose. Then send it a `initialized` notification which will
+//! have no response.
+//!
+//! ```no_run
+//! Content-Length: 59
+//!
+//! {"jsonrpc": "2.0", "method": "initialized", "params": {}}
+//! ```
+//!
+//! Once these two are sent, then we enter the main loop of the server. The only request this
+//! example can handle is `gotoDefinition`:
+//!
+//! ```no_run
+//! Content-Length: 159
+//!
+//! {"jsonrpc": "2.0", "method": "textDocument/definition", "id": 2, "params": {"textDocument": {"uri": "file://temp"}, "position": {"line": 1, "character": 1}}}
+//! ```
+//!
+//! To finish up without errors, send a shutdown request:
+//!
+//! ```no_run
+//! Content-Length: 67
+//!
+//! {"jsonrpc": "2.0", "method": "shutdown", "id": 3, "params": null}
+//! ```
+//!
+//! The server will exit the main loop and finally we send a `shutdown` notification to stop
+//! the server.
+//!
+//! ```
+//! Content-Length: 54
+//!
+//! {"jsonrpc": "2.0", "method": "exit", "params": null}
+//! ```
+use crossbeam_channel::{Sender, Receiver};
+use lsp_types::{
+    ServerCapabilities, InitializeParams,
+    request::{GotoDefinition, GotoDefinitionResponse},
+};
+use log::info;
+use gen_lsp_server::{
+    run_server, stdio_transport, handle_shutdown, RawMessage, RawResponse, RawRequest,
+};
+fn main() -> Result<(), failure::Error> {
+    // Set up logging. Because `stdio_transport` gets a lock on stdout and stdin, we must have
+    // our logging only write out to stderr.
+    flexi_logger::Logger::with_str("info").start().unwrap();
+    info!("starting generic LSP server");
+    // Create the transport. Includes the stdio (stdin and stdout) versions but this could
+    // also be implemented to use sockets or HTTP.
+    let (receiver, sender, io_threads) = stdio_transport();
+    // Run the server and wait for the two threads to end (typically by trigger LSP Exit event).
+    run_server(ServerCapabilities::default(), receiver, sender, main_loop)?;
+    io_threads.join()?;
+    // Shut down gracefully.
+    info!("shutting down server");
+    Ok(())
+}
+fn main_loop(
+    _params: InitializeParams,
+    receiver: &Receiver<RawMessage>,
+    sender: &Sender<RawMessage>,
+) -> Result<(), failure::Error> {
+    info!("starting example main loop");
+    for msg in receiver {
+        info!("got msg: {:?}", msg);
+        match msg {
+            RawMessage::Request(req) => {
+                let req = match log_handle_shutdown(req, sender) {
+                    None => return Ok(()),
+                    Some(req) => req,
+                };
+                info!("got request: {:?}", req);
+                match req.cast::<GotoDefinition>() {
+                    Ok((id, params)) => {
+                        info!("got gotoDefinition request #{}: {:?}", id, params);
+                        let resp = RawResponse::ok::<GotoDefinition>(
+                            id,
+                            &Some(GotoDefinitionResponse::Array(Vec::new())),
+                        );
+                        info!("sending gotoDefinition response: {:?}", resp);
+                        sender.send(RawMessage::Response(resp))?;
+                        continue;
+                    }
+                    Err(req) => req,
+                };
+                // ...
+            }
+            RawMessage::Response(resp) => {
+                info!("got response: {:?}", resp);
+            }
+            RawMessage::Notification(not) => {
+                info!("got notification: {:?}", not);
+            }
+        }
+    }
+    Ok(())
+}
+pub fn log_handle_shutdown(req: RawRequest, sender: &Sender<RawMessage>) -> Option<RawRequest> {
+    info!("handle_shutdown: {:?}", req);
+    handle_shutdown(req, sender)
+}
diff --git a/crates/gen_lsp_server/src/lib.rs b/crates/gen_lsp_server/src/lib.rs
index edbdda6c8..1cd5a3a7c 100644
--- a/crates/gen_lsp_server/src/lib.rs
+++ b/crates/gen_lsp_server/src/lib.rs
@@ -2,21 +2,16 @@
 //! This crate handles protocol handshaking and parsing messages, while you
 //! control the message dispatch loop yourself.
 //!
-//! Run with `RUST_LOG=sync_lsp_server=debug` to see all the messages.
+//! Run with `RUST_LOG=gen_lsp_server=debug` to see all the messages.
 //!
 //! ```no_run
-//! extern crate gen_lsp_server;
-//! extern crate lsp_types;
-//! extern crate failure;
-//! extern crate crossbeam_channel;
-//!
 //! use crossbeam_channel::{Sender, Receiver};
 //! use lsp_types::{ServerCapabilities, InitializeParams, request::{GotoDefinition, GotoDefinitionResponse}};
 //! use gen_lsp_server::{run_server, stdio_transport, handle_shutdown, RawMessage, RawResponse};
 //!
 //! fn main() -> Result<(), failure::Error> {
 //!     let (receiver, sender, io_threads) = stdio_transport();
-//!     gen_lsp_server::run_server(
+//!     run_server(
 //!         ServerCapabilities::default(),
 //!         receiver,
 //!         sender,
@@ -38,13 +33,13 @@
 //!                     None => return Ok(()),
 //!                     Some(req) => req,
 //!                 };
-//!                 let req = match req.cast::<GotoDefinition>() {
+//!                 match req.cast::<GotoDefinition>() {
 //!                     Ok((id, _params)) => {
 //!                         let resp = RawResponse::ok::<GotoDefinition>(
 //!                             id,
 //!                             &Some(GotoDefinitionResponse::Array(Vec::new())),
 //!                         );
-//!                         sender.send(RawMessage::Response(resp));
+//!                         sender.send(RawMessage::Response(resp))?;
 //!                         continue;
 //!                     },
 //!                     Err(req) => req,
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index ae97a1ab5..28eb0226b 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -100,7 +100,7 @@ mod split_import;
 mod remove_dbg;
 pub mod auto_import;
 mod add_missing_impl_members;
-mod move_guard_to_arm_body;
+mod move_guard;
 fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
    &[
@@ -119,7 +119,8 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
        add_missing_impl_members::add_missing_impl_members,
        add_missing_impl_members::add_missing_default_members,
        inline_local_variable::inline_local_varialbe,
-        move_guard_to_arm_body::move_guard_to_arm_body,
+        move_guard::move_guard_to_arm_body,
+        move_guard::move_arm_cond_to_match_guard,
    ]
 }
diff --git a/crates/ra_assists/src/move_guard.rs b/crates/ra_assists/src/move_guard.rs
new file mode 100644
index 000000000..22ba91fb7
--- /dev/null
+++ b/crates/ra_assists/src/move_guard.rs
@@ -0,0 +1,260 @@
+use hir::db::HirDatabase;
+use ra_syntax::{
+    TextUnit,
+    SyntaxElement,
+    ast::{MatchArm, AstNode, AstToken, IfExpr},
+    ast,
+};
+use crate::{AssistCtx, Assist, AssistId};
+pub(crate) fn move_guard_to_arm_body(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let match_arm = ctx.node_at_offset::<MatchArm>()?;
+    let guard = match_arm.guard()?;
+    let space_before_guard = guard.syntax().prev_sibling_or_token();
+    let guard_conditions = guard.expr()?;
+    let arm_expr = match_arm.expr()?;
+    let buf = format!("if {} {{ {} }}", guard_conditions.syntax().text(), arm_expr.syntax().text());
+    ctx.add_action(AssistId("move_guard_to_arm_body"), "move guard to arm body", |edit| {
+        edit.target(guard.syntax().range());
+        let offseting_amount = match space_before_guard {
+            Some(SyntaxElement::Token(tok)) => {
+                if let Some(_) = ast::Whitespace::cast(tok) {
+                    let ele = space_before_guard.unwrap().range();
+                    edit.delete(ele);
+                    ele.len()
+                } else {
+                    TextUnit::from(0)
+                }
+            }
+            _ => TextUnit::from(0),
+        };
+        edit.delete(guard.syntax().range());
+        edit.replace_node_and_indent(arm_expr.syntax(), buf);
+        edit.set_cursor(arm_expr.syntax().range().start() + TextUnit::from(3) - offseting_amount);
+    });
+    ctx.build()
+}
+pub(crate) fn move_arm_cond_to_match_guard(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let match_arm: &MatchArm = ctx.node_at_offset::<MatchArm>()?;
+    let last_match_pat = match_arm.pats().last()?;
+    let arm_body = match_arm.expr()?;
+    let if_expr: &IfExpr = IfExpr::cast(arm_body.syntax())?;
+    let cond = if_expr.condition()?;
+    let then_block = if_expr.then_branch()?;
+    // Not support if with else branch
+    if let Some(_) = if_expr.else_branch() {
+        return None;
+    }
+    // Not support moving if let to arm guard
+    if let Some(_) = cond.pat() {
+        return None;
+    }
+    let buf = format!(" if {}", cond.syntax().text());
+    ctx.add_action(
+        AssistId("move_arm_cond_to_match_guard"),
+        "move condition to match guard",
+        |edit| {
+            edit.target(if_expr.syntax().range());
+            let then_only_expr = then_block.statements().next().is_none();
+            match then_block.expr() {
+                Some(then_expr) if then_only_expr => {
+                    edit.replace(if_expr.syntax().range(), then_expr.syntax().text())
+                }
+                _ => edit.replace(if_expr.syntax().range(), then_block.syntax().text()),
+            }
+            edit.insert(last_match_pat.syntax().range().end(), buf);
+            edit.set_cursor(last_match_pat.syntax().range().end() + TextUnit::from(1));
+        },
+    );
+    ctx.build()
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{ check_assist, check_assist_target, check_assist_not_applicable };
+    #[test]
+    fn move_guard_to_arm_body_target() {
+        check_assist_target(
+            move_guard_to_arm_body,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' <|>if chars.clone().next() == Some('\n') => false,
+                    _ => true
+                }
+            }
+            "#,
+            r#"if chars.clone().next() == Some('\n')"#,
+        );
+    }
+    #[test]
+    fn move_guard_to_arm_body_works() {
+        check_assist(
+            move_guard_to_arm_body,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' <|>if chars.clone().next() == Some('\n') => false,
+                    _ => true
+                }
+            }
+            "#,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' => if chars.clone().next() == Some('\n') { <|>false },
+                    _ => true
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn move_guard_to_arm_body_works_complex_match() {
+        check_assist(
+            move_guard_to_arm_body,
+            r#"
+            fn f() {
+                match x {
+                    <|>y @ 4 | y @ 5    if y > 5 => true,
+                    _ => false
+                }
+            }
+            "#,
+            r#"
+            fn f() {
+                match x {
+                    y @ 4 | y @ 5 => if y > 5 { <|>true },
+                    _ => false
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn move_arm_cond_to_match_guard_works() {
+        check_assist(
+            move_arm_cond_to_match_guard,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' => if chars.clone().next() == Some('\n') { <|>false },
+                    _ => true
+                }
+            }
+            "#,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' <|>if chars.clone().next() == Some('\n') => false,
+                    _ => true
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn move_arm_cond_to_match_guard_if_let_not_works() {
+        check_assist_not_applicable(
+            move_arm_cond_to_match_guard,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' => if let Some(_) = chars.clone().next() { <|>false },
+                    _ => true
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn move_arm_cond_to_match_guard_if_empty_body_works() {
+        check_assist(
+            move_arm_cond_to_match_guard,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' => if chars.clone().next().is_some() { <|> },
+                    _ => true
+                }
+            }
+            "#,
+            r#"
+            fn f() {
+                let t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' <|>if chars.clone().next().is_some() => {  },
+                    _ => true
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn move_arm_cond_to_match_guard_if_multiline_body_works() {
+        check_assist(
+            move_arm_cond_to_match_guard,
+            r#"
+            fn f() {
+                let mut t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' => if chars.clone().next().is_some() {
+                        t = 'e';<|>
+                        false
+                    },
+                    _ => true
+                }
+            }
+            "#,
+            r#"
+            fn f() {
+                let mut t = 'a';
+                let chars = "abcd";
+                match t {
+                    '\r' <|>if chars.clone().next().is_some() => {
+                        t = 'e';
+                        false
+                    },
+                    _ => true
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/move_guard_to_arm_body.rs b/crates/ra_assists/src/move_guard_to_arm_body.rs
deleted file mode 100644
index a8ca19f5d..000000000
--- a/crates/ra_assists/src/move_guard_to_arm_body.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-use hir::db::HirDatabase;
-use ra_syntax::{
-    TextUnit,
-    SyntaxElement,
-    ast::{MatchArm, AstNode, AstToken},
-    ast,
-};
-use crate::{AssistCtx, Assist, AssistId};
-pub(crate) fn move_guard_to_arm_body(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let match_arm = ctx.node_at_offset::<MatchArm>()?;
-    let guard = match_arm.guard()?;
-    let space_before_guard = guard.syntax().prev_sibling_or_token();
-    let guard_conditions = guard.expr()?;
-    let arm_expr = match_arm.expr()?;
-    let buf = format!("if {} {{ {} }}", guard_conditions.syntax().text(), arm_expr.syntax().text());
-    ctx.add_action(AssistId("move_guard_to_arm_body"), "move guard to arm body", |edit| {
-        edit.target(guard.syntax().range());
-        let offseting_amount = match space_before_guard {
-            Some(SyntaxElement::Token(tok)) => {
-                if let Some(_) = ast::Whitespace::cast(tok) {
-                    let ele = space_before_guard.unwrap().range();
-                    edit.delete(ele);
-                    ele.len()
-                } else {
-                    TextUnit::from(0)
-                }
-            }
-            _ => TextUnit::from(0),
-        };
-        edit.delete(guard.syntax().range());
-        edit.replace_node_and_indent(arm_expr.syntax(), buf);
-        edit.set_cursor(arm_expr.syntax().range().start() + TextUnit::from(3) - offseting_amount);
-    });
-    ctx.build()
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::helpers::{ check_assist, check_assist_target };
-    #[test]
-    fn move_guard_to_arm_body_target() {
-        check_assist_target(
-            move_guard_to_arm_body,
-            r#"
-            fn f() {
-                let t = 'a';
-                let chars = "abcd";
-                match t {
-                    '\r' <|>if chars.clone().next() == Some('\n') => false,
-                    _ => true
-                }
-            }
-            "#,
-            r#"if chars.clone().next() == Some('\n')"#,
-        );
-    }
-    #[test]
-    fn move_guard_to_arm_body_works() {
-        check_assist(
-            move_guard_to_arm_body,
-            r#"
-            fn f() {
-                let t = 'a';
-                let chars = "abcd";
-                match t {
-                    '\r' <|>if chars.clone().next() == Some('\n') => false,
-                    _ => true
-                }
-            }
-            "#,
-            r#"
-            fn f() {
-                let t = 'a';
-                let chars = "abcd";
-                match t {
-                    '\r' => if chars.clone().next() == Some('\n') { <|>false },
-                    _ => true
-                }
-            }
-            "#,
-        );
-    }
-    #[test]
-    fn move_guard_to_arm_body_works_complex_match() {
-        check_assist(
-            move_guard_to_arm_body,
-            r#"
-            fn f() {
-                match x {
-                    <|>y @ 4 | y @ 5    if y > 5 => true,
-                    _ => false
-                }
-            }
-            "#,
-            r#"
-            fn f() {
-                match x {
-                    y @ 4 | y @ 5 => if y > 5 { <|>true },
-                    _ => false
-                }
-            }
-            "#,
-        );
-    }
-}
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index 08aef9bf5..5328303d2 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -12,4 +12,5 @@ parking_lot = "0.7.0"
 ra_arena = { path = "../ra_arena" }
 ra_syntax = { path = "../ra_syntax" }
+ra_prof = { path = "../ra_prof" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index bf567721a..68b9a7143 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -6,6 +6,7 @@ use std::{panic, sync::Arc};
 use ra_syntax::{TextUnit, TextRange, SourceFile, TreeArc};
 use relative_path::RelativePathBuf;
+use ra_prof::profile;
 pub use ::salsa as salsa;
 pub use crate::{
@@ -72,6 +73,7 @@ pub trait SourceDatabase: CheckCanceled + std::fmt::Debug {
    #[salsa::input]
    fn file_text(&self, file_id: FileId) -> Arc<String>;
    // Parses the file into the syntax tree.
+    #[salsa::invoke(parse_query)]
    fn parse(&self, file_id: FileId) -> TreeArc<SourceFile>;
    /// Path to a file, relative to the root of its source root.
    #[salsa::input]
@@ -96,7 +98,8 @@ fn source_root_crates(db: &impl SourceDatabase, id: SourceRootId) -> Arc<Vec<Cra
    Arc::new(res)
 }
-fn parse(db: &impl SourceDatabase, file_id: FileId) -> TreeArc<SourceFile> {
+fn parse_query(db: &impl SourceDatabase, file_id: FileId) -> TreeArc<SourceFile> {
+    let _p = profile("parse_query");
    let text = db.file_text(file_id);
    SourceFile::parse(&*text)
 }
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index f901a7432..2eb7f0da0 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -5,6 +5,7 @@ use std::{
 use ra_db::{FileId, salsa};
 use ra_syntax::{TreeArc, AstNode, ast, SyntaxNode};
+use ra_prof::profile;
 use mbe::MacroRules;
 use crate::{
@@ -60,6 +61,7 @@ impl HirFileId {
        db: &impl DefDatabase,
        file_id: HirFileId,
    ) -> Option<TreeArc<SyntaxNode>> {
+        let _p = profile("parse_or_expand_query");
        match file_id.0 {
            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).syntax().to_owned()),
            HirFileIdRepr::Macro(macro_file) => {
diff --git a/crates/ra_ide_api/src/display/navigation_target.rs b/crates/ra_ide_api/src/display/navigation_target.rs
index 7ea336c50..1c694cbc9 100644
--- a/crates/ra_ide_api/src/display/navigation_target.rs
+++ b/crates/ra_ide_api/src/display/navigation_target.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    ast::{self, NameOwner, VisibilityOwner, TypeAscriptionOwner},
    algo::visit::{visitor, Visitor},
 };
-use hir::{ModuleSource, FieldSource, ImplItem, Either};
+use hir::{ModuleSource, FieldSource, ImplItem};
 use crate::{FileSymbol, db::RootDatabase};
@@ -77,17 +77,12 @@ impl NavigationTarget {
    pub(crate) fn from_pat(
        db: &RootDatabase,
        file_id: FileId,
-        pat: Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>,
+        pat: AstPtr<ast::Pat>,
    ) -> NavigationTarget {
        let file = db.parse(file_id);
-        let (name, full_range) = match pat {
+        let (name, full_range) = match pat.to_node(file.syntax()).kind() {
-            Either::A(pat) => match pat.to_node(file.syntax()).kind() {
+            ast::PatKind::BindPat(pat) => return NavigationTarget::from_bind_pat(file_id, &pat),
-                ast::PatKind::BindPat(pat) => {
+            _ => ("_".into(), pat.syntax_node_ptr().range()),
-                    return NavigationTarget::from_bind_pat(file_id, &pat)
-                }
-                _ => ("_".into(), pat.syntax_node_ptr().range()),
-            },
-            Either::B(slf) => ("self".into(), slf.syntax_node_ptr().range()),
        };
        NavigationTarget {
            file_id,
@@ -99,6 +94,21 @@ impl NavigationTarget {
        }
    }
+    pub(crate) fn from_self_param(
+        file_id: FileId,
+        par: AstPtr<ast::SelfParam>,
+    ) -> NavigationTarget {
+        let (name, full_range) = ("self".into(), par.syntax_node_ptr().range());
+        NavigationTarget {
+            file_id,
+            name,
+            full_range,
+            focus_range: None,
+            kind: NAME,
+            container_name: None,
+        }
+    }
    pub(crate) fn from_module(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
        let (file_id, source) = module.definition_source(db);
        let file_id = file_id.as_original_file();
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index adae29e9c..9c56f17f2 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -1,12 +1,19 @@
 use ra_db::{FileId, SourceDatabase};
 use ra_syntax::{
    AstNode, ast,
-    algo::{find_node_at_offset, visit::{visitor, Visitor}},
+    algo::{
+        find_node_at_offset,
+        visit::{visitor, Visitor},
+    },
    SyntaxNode,
 };
-use test_utils::tested_by;
-use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
+use crate::{
+    FilePosition, NavigationTarget,
+    db::RootDatabase,
+    RangeInfo,
+    name_ref_kind::{NameRefKind::*, classify_name_ref},
+};
 pub(crate) fn goto_definition(
    db: &RootDatabase,
@@ -50,85 +57,24 @@ pub(crate) fn reference_definition(
    let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
-    // Special cases:
+    match classify_name_ref(db, &analyzer, name_ref) {
+        Some(Method(func)) => return Exact(NavigationTarget::from_function(db, func)),
-    // Check if it is a method
+        Some(Macro(mac)) => return Exact(NavigationTarget::from_macro_def(db, mac)),
-    if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
+        Some(FieldAccess(field)) => return Exact(NavigationTarget::from_field(db, field)),
-        tested_by!(goto_definition_works_for_methods);
+        Some(AssocItem(assoc)) => return Exact(NavigationTarget::from_impl_item(db, assoc)),
-        if let Some(func) = analyzer.resolve_method_call(method_call) {
+        Some(Def(def)) => return Exact(NavigationTarget::from_def(db, def)),
-            return Exact(NavigationTarget::from_function(db, func));
+        Some(SelfType(ty)) => {
-        }
+            if let Some((def_id, _)) = ty.as_adt() {
-    }
+                return Exact(NavigationTarget::from_adt_def(db, def_id));
-    //it could be a macro call
-    if let Some(macro_call) = name_ref
-        .syntax()
-        .parent()
-        .and_then(|node| node.parent())
-        .and_then(|node| node.parent())
-        .and_then(ast::MacroCall::cast)
-    {
-        tested_by!(goto_definition_works_for_macros);
-        if let Some(macro_call) = analyzer.resolve_macro_call(macro_call) {
-            return Exact(NavigationTarget::from_macro_def(db, macro_call));
-        }
-    }
-    // It could also be a field access
-    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
-        tested_by!(goto_definition_works_for_fields);
-        if let Some(field) = analyzer.resolve_field(field_expr) {
-            return Exact(NavigationTarget::from_field(db, field));
-        };
-    }
-    // It could also be a named field
-    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::NamedField::cast) {
-        tested_by!(goto_definition_works_for_named_fields);
-        let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
-        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, lit.into())) {
-            if let Some((hir::AdtDef::Struct(s), _)) = ty.as_adt() {
-                let hir_path = hir::Path::from_name_ref(name_ref);
-                let hir_name = hir_path.as_ident().unwrap();
-                if let Some(field) = s.field(db, hir_name) {
-                    return Exact(NavigationTarget::from_field(db, field));
-                }
            }
        }
-    }
+        Some(Pat(pat)) => return Exact(NavigationTarget::from_pat(db, file_id, pat)),
+        Some(SelfParam(par)) => return Exact(NavigationTarget::from_self_param(file_id, par)),
-    // General case, a path or a local:
+        Some(GenericParam(_)) => {
-    if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
+            // FIXME: go to the generic param def
-        if let Some(resolved) = analyzer.resolve_path(db, path) {
-            match resolved {
-                hir::PathResolution::Def(def) => return Exact(NavigationTarget::from_def(db, def)),
-                hir::PathResolution::LocalBinding(pat) => {
-                    let nav = NavigationTarget::from_pat(db, file_id, pat);
-                    return Exact(nav);
-                }
-                hir::PathResolution::GenericParam(..) => {
-                    // FIXME: go to the generic param def
-                }
-                hir::PathResolution::Macro(def) => {
-                    let nav = NavigationTarget::from_macro_def(db, def);
-                    return Exact(nav);
-                }
-                hir::PathResolution::SelfType(impl_block) => {
-                    let ty = impl_block.target_ty(db);
-                    if let Some((def_id, _)) = ty.as_adt() {
-                        return Exact(NavigationTarget::from_adt_def(db, def_id));
-                    }
-                }
-                hir::PathResolution::AssocItem(assoc) => {
-                    return Exact(NavigationTarget::from_impl_item(db, assoc));
-                }
-            }
        }
-    }
+        None => {}
+    };
    // Fallback index based approach:
    let navs = crate::symbol_index::index_resolve(db, name_ref)
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index d4be8bd6c..f78348f74 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -18,6 +18,7 @@ mod change;
 mod status;
 mod completion;
 mod runnables;
+mod name_ref_kind;
 mod goto_definition;
 mod goto_type_definition;
 mod extend_selection;
@@ -53,10 +54,7 @@ use ra_db::{
 };
 use relative_path::RelativePathBuf;
-use crate::{
+use crate::{symbol_index::FileSymbol, db::LineIndexDatabase};
-    symbol_index::FileSymbol,
-    db::LineIndexDatabase,
-};
 pub use crate::{
    change::{AnalysisChange, LibraryData},
@@ -73,10 +71,7 @@ pub use crate::{
    display::{FunctionSignature, NavigationTarget, StructureNode, file_structure},
 };
-pub use ra_db::{
+pub use ra_db::{Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId, Edition};
-    Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId,
-    Edition
-};
 pub use hir::Documentation;
 // We use jemalloc mainly to get heap usage statistics, actual performance
diff --git a/crates/ra_ide_api/src/name_ref_kind.rs b/crates/ra_ide_api/src/name_ref_kind.rs
new file mode 100644
index 000000000..b498fe495
--- /dev/null
+++ b/crates/ra_ide_api/src/name_ref_kind.rs
@@ -0,0 +1,95 @@
+use ra_syntax::{AstNode, AstPtr, ast};
+use hir::Either;
+use crate::db::RootDatabase;
+use test_utils::tested_by;
+pub enum NameRefKind {
+    Method(hir::Function),
+    Macro(hir::MacroByExampleDef),
+    FieldAccess(hir::StructField),
+    AssocItem(hir::ImplItem),
+    Def(hir::ModuleDef),
+    SelfType(hir::Ty),
+    Pat(AstPtr<ast::Pat>),
+    SelfParam(AstPtr<ast::SelfParam>),
+    GenericParam(u32),
+}
+pub(crate) fn classify_name_ref(
+    db: &RootDatabase,
+    analyzer: &hir::SourceAnalyzer,
+    name_ref: &ast::NameRef,
+) -> Option<NameRefKind> {
+    use NameRefKind::*;
+    // Check if it is a method
+    if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
+        tested_by!(goto_definition_works_for_methods);
+        if let Some(func) = analyzer.resolve_method_call(method_call) {
+            return Some(Method(func));
+        }
+    }
+    // It could be a macro call
+    if let Some(macro_call) = name_ref
+        .syntax()
+        .parent()
+        .and_then(|node| node.parent())
+        .and_then(|node| node.parent())
+        .and_then(ast::MacroCall::cast)
+    {
+        tested_by!(goto_definition_works_for_macros);
+        if let Some(mac) = analyzer.resolve_macro_call(macro_call) {
+            return Some(Macro(mac));
+        }
+    }
+    // It could also be a field access
+    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
+        tested_by!(goto_definition_works_for_fields);
+        if let Some(field) = analyzer.resolve_field(field_expr) {
+            return Some(FieldAccess(field));
+        };
+    }
+    // It could also be a named field
+    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::NamedField::cast) {
+        tested_by!(goto_definition_works_for_named_fields);
+        let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
+        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, lit.into())) {
+            if let Some((hir::AdtDef::Struct(s), _)) = ty.as_adt() {
+                let hir_path = hir::Path::from_name_ref(name_ref);
+                let hir_name = hir_path.as_ident().unwrap();
+                if let Some(field) = s.field(db, hir_name) {
+                    return Some(FieldAccess(field));
+                }
+            }
+        }
+    }
+    // General case, a path or a local:
+    if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
+        if let Some(resolved) = analyzer.resolve_path(db, path) {
+            return match resolved {
+                hir::PathResolution::Def(def) => Some(Def(def)),
+                hir::PathResolution::LocalBinding(Either::A(pat)) => Some(Pat(pat)),
+                hir::PathResolution::LocalBinding(Either::B(par)) => Some(SelfParam(par)),
+                hir::PathResolution::GenericParam(par) => {
+                    // FIXME: get generic param def
+                    Some(GenericParam(par))
+                }
+                hir::PathResolution::Macro(def) => Some(Macro(def)),
+                hir::PathResolution::SelfType(impl_block) => {
+                    let ty = impl_block.target_ty(db);
+                    Some(SelfType(ty))
+                }
+                hir::PathResolution::AssocItem(assoc) => Some(AssocItem(assoc)),
+            };
+        }
+    }
+    None
+}
diff --git a/crates/ra_ide_api/src/snapshots/tests__highlighting.snap b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
index 72029e0ed..9d4c04db3 100644
--- a/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
+++ b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
@@ -1,33 +1,145 @@
 ---
-created: "2019-03-23T16:20:31.394314144Z"
+created: "2019-05-23T12:10:32.628883358Z"
-creator: insta@0.7.1
+creator: insta@0.8.1
 source: crates/ra_ide_api/src/syntax_highlighting.rs
 expression: result
 ---
 Ok(
    [
        HighlightedRange {
-            range: [1; 11),
+            range: [1; 24),
+            tag: "attribute"
+        },
+        HighlightedRange {
+            range: [25; 31),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [32; 35),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [42; 45),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [46; 47),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [49; 52),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [58; 61),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [62; 63),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [65; 68),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [73; 75),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [76; 79),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [80; 81),
+            tag: "type"
+        },
+        HighlightedRange {
+            range: [80; 81),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [88; 89),
+            tag: "type"
+        },
+        HighlightedRange {
+            range: [96; 110),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [117; 127),
            tag: "comment"
        },
        HighlightedRange {
-            range: [12; 14),
+            range: [128; 130),
            tag: "keyword"
        },
        HighlightedRange {
-            range: [15; 19),
+            range: [131; 135),
            tag: "function"
        },
        HighlightedRange {
-            range: [29; 37),
+            range: [145; 153),
            tag: "macro"
        },
        HighlightedRange {
-            range: [38; 50),
+            range: [154; 166),
            tag: "string"
        },
        HighlightedRange {
-            range: [52; 54),
+            range: [168; 170),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [178; 181),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [182; 185),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [186; 189),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [197; 200),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [192; 195),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [208; 211),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [212; 216),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [226; 227),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [232; 233),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [242; 248),
+            tag: "keyword.unsafe"
+        },
+        HighlightedRange {
+            range: [251; 254),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [255; 262),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [263; 264),
            tag: "literal"
        }
    ]
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 2158291dc..89f20260f 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -40,8 +40,41 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
            COMMENT => "comment",
            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
            ATTR => "attribute",
-            NAME_REF => "text",
+            NAME_REF => {
+                if let Some(name_ref) = node.as_node().and_then(|n| ast::NameRef::cast(n)) {
+                    use crate::name_ref_kind::{classify_name_ref, NameRefKind::*};
+                    use hir::{ModuleDef, ImplItem};
+                    // FIXME: try to reuse the SourceAnalyzers
+                    let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+                    match classify_name_ref(db, &analyzer, name_ref) {
+                        Some(Method(_)) => "function",
+                        Some(Macro(_)) => "macro",
+                        Some(FieldAccess(_)) => "field",
+                        Some(AssocItem(ImplItem::Method(_))) => "function",
+                        Some(AssocItem(ImplItem::Const(_))) => "constant",
+                        Some(AssocItem(ImplItem::TypeAlias(_))) => "type",
+                        Some(Def(ModuleDef::Module(_))) => "module",
+                        Some(Def(ModuleDef::Function(_))) => "function",
+                        Some(Def(ModuleDef::Struct(_))) => "type",
+                        Some(Def(ModuleDef::Enum(_))) => "type",
+                        Some(Def(ModuleDef::EnumVariant(_))) => "constant",
+                        Some(Def(ModuleDef::Const(_))) => "constant",
+                        Some(Def(ModuleDef::Static(_))) => "constant",
+                        Some(Def(ModuleDef::Trait(_))) => "type",
+                        Some(Def(ModuleDef::TypeAlias(_))) => "type",
+                        Some(SelfType(_)) => "type",
+                        Some(Pat(_)) => "text",
+                        Some(SelfParam(_)) => "type",
+                        Some(GenericParam(_)) => "type",
+                        None => "text",
+                    }
+                } else {
+                    "text"
+                }
+            }
            NAME => "function",
+            TYPE_ALIAS_DEF | TYPE_ARG | TYPE_PARAM => "type",
            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
            LIFETIME => "parameter",
            T![unsafe] => "keyword.unsafe",
@@ -87,9 +120,23 @@ mod tests {
    fn test_highlighting() {
        let (analysis, file_id) = single_file(
            r#"
+#[derive(Clone, Debug)]
+struct Foo {
+    pub x: i32,
+    pub y: i32,
+}
+fn foo<T>() -> T {
+    unimplemented!();
+}
 // comment
 fn main() {}
    println!("Hello, {}!", 92);
+    let mut vec = Vec::new();
+    vec.push(Foo { x: 0, y: 1 });
+    unsafe { vec.set_len(0); }
 "#,
        );
        let result = analysis.highlight(file_id);
diff --git a/docs/user/README.md b/docs/user/README.md
index 1b4d13d0f..affb96939 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -64,7 +64,7 @@ for details.
 * `rust-analyzer.showWorkspaceLoadedNotification`: to ease troubleshooting, a
  notification is shown by default when a workspace is loaded
 * `rust-analyzer.enableEnhancedTyping`: by default, rust-analyzer intercepts
-  `Enter` key to make it easier to continue comments
+  `Enter` key to make it easier to continue comments. Note that it may conflict with VIM emulation plugin.
 * `rust-analyzer.raLspServerPath`: path to `ra_lsp_server` executable
 * `rust-analyzer.enableCargoWatchOnStartup`: prompt to install & enable `cargo
  watch` for live error highlighting (note, this **does not** use rust-analyzer)
diff --git a/docs/user/features.md b/docs/user/features.md
index a714574fb..22470bc56 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -390,14 +390,14 @@ fn foo() {
 - Move guard expression to match arm body
 ```rust
-//before:
+// before:
 fn f() {
    match x {
        <|>y @ 4 | y @ 5    if y > 5 => true,
        _ => false
    }
 }
-//after:
+// after:
 fn f() {
    match x {
        y @ 4 | y @ 5 => if y > 5 { <|>true },
@@ -406,6 +406,35 @@ fn f() {
 }
 ```
+- Move if condition to match arm guard
+```rust
+// before:
+fn f() {
+    let mut t = 'a';
+    let chars = "abcd";
+    match t {
+        '\r' => if chars.clone().next().is_some() {
+            t = 'e';<|>
+            false
+        },
+        _ => true
+    }
+}
+// after:
+fn f() {
+    let mut t = 'a';
+    let chars = "abcd";
+    match t {
+        '\r' <|>if chars.clone().next().is_some() => {
+            t = 'e';
+            false
+        },
+        _ => true
+    }
+}
+```
 ### Magic Completions
 In addition to usual reference completion, rust-analyzer provides some ✨magic✨
diff --git a/editors/code/package.json b/editors/code/package.json
index 750c97bb1..cde5fbcb8 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -371,12 +371,57 @@
            },
            {
                "id": "ralsp.macro",
-                "description": "Color for DFAF8F",
+                "description": "Color for macros",
                "defaults": {
                    "dark": "#BFEBBF",
                    "light": "#DD6718",
                    "highContrast": "#ED7718"
                }
+            },
+            {
+                "id": "ralsp.constant",
+                "description": "Color for constants",
+                "defaults": {
+                    "dark": "#569cd6",
+                    "light": "#267cb6",
+                    "highContrast": "#569cd6"
+                }
+            },
+            {
+                "id": "ralsp.type",
+                "description": "Color for types",
+                "defaults": {
+                    "dark": "#4EC9B0",
+                    "light": "#267F99",
+                    "highContrast": "#4EC9B0"
+                }
+            },
+            {
+                "id": "ralsp.field",
+                "description": "Color for fields",
+                "defaults": {
+                    "dark": "#4EC9B0",
+                    "light": "#267F99",
+                    "highContrast": "#4EC9B0"
+                }
+            },
+            {
+                "id": "ralsp.variable",
+                "description": "Color for variables",
+                "defaults": {
+                    "dark": "#4EC9B0",
+                    "light": "#267F99",
+                    "highContrast": "#4EC9B0"
+                }
+            },
+            {
+                "id": "ralsp.module",
+                "description": "Color for modules",
+                "defaults": {
+                    "dark": "#D4D4D4",
+                    "light": "#000000",
+                    "highContrast": "#FFFFFF"
+                }
            }
        ]
    }
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
index e1a68544a..8389d94b8 100644
--- a/editors/code/src/highlighting.ts
+++ b/editors/code/src/highlighting.ts
@@ -33,11 +33,16 @@ export class Highlighter {
            colorContrib('keyword.unsafe'),
            colorContrib('function'),
            colorContrib('parameter'),
+            colorContrib('constant'),
+            colorContrib('type'),
            colorContrib('builtin'),
            colorContrib('text'),
            colorContrib('attribute'),
            colorContrib('literal'),
-            colorContrib('macro')
+            colorContrib('macro'),
+            colorContrib('variable'),
+            colorContrib('field'),
+            colorContrib('module')
        ];
        return new Map<string, vscode.TextEditorDecorationType>(decorations);