49 files changed, 1464 insertions, 504 deletions
diff --git a/crates/ra_arena/src/map.rs b/crates/ra_arena/src/map.rs
index 5e764113d..0f33907c0 100644
--- a/crates/ra_arena/src/map.rs
+++ b/crates/ra_arena/src/map.rs
@@ -14,14 +14,8 @@ pub struct ArenaMap<ID, V> {
 impl<T, V> ArenaMap<Idx<T>, V> {
    pub fn insert(&mut self, id: Idx<T>, t: V) {
        let idx = Self::to_idx(id);
-        if self.v.capacity() <= idx {
-            self.v.reserve(idx + 1 - self.v.capacity());
+        self.v.resize_with((idx + 1).max(self.v.len()), || None);
-        }
-        if self.v.len() <= idx {
-            while self.v.len() <= idx {
-                self.v.push(None);
-            }
-        }
        self.v[idx] = Some(t);
    }
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index add82e5b1..8d1af9933 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -1,15 +1,11 @@
-//! FIXME: write short doc here
 use std::iter;
 use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
+use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use crate::{Assist, AssistCtx, AssistId};
-use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
-use ast::{MatchArm, Pat};
 // Assist: fill_match_arms
 //
@@ -97,10 +93,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
    }
    ctx.add_assist(AssistId("fill_match_arms"), "Fill match arms", |edit| {
-        arms.extend(missing_arms);
+        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
-        let indent_level = IndentLevel::from_node(match_arm_list.syntax());
-        let new_arm_list = indent_level.increase_indent(make::match_arm_list(arms));
        edit.target(match_expr.syntax().text_range());
        edit.set_cursor(expr.syntax().text_range().start());
@@ -655,4 +648,93 @@ mod tests {
            "#,
        );
    }
+    #[test]
+    fn fill_match_arms_preserves_comments() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match a {
+                    // foo bar baz<|>
+                    A::One => {}
+                    // This is where the rest should be
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match <|>a {
+                    // foo bar baz
+                    A::One => {}
+                    // This is where the rest should be
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_preserves_comments_empty() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match a {
+                    // foo bar baz<|>
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match <|>a {
+                    // foo bar baz
+                    A::One => {}
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_placeholder() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A { One, Two, }
+            fn foo(a: A) {
+                match a<|> {
+                    _ => (),
+                }
+            }
+            "#,
+            r#"
+            enum A { One, Two, }
+            fn foo(a: A) {
+                match <|>a {
+                    A::One => {}
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
 }
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index 741345a21..c9a9ddc12 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 edition = "2018"
-name = "ra_cargo_watch"
+name = "ra_flycheck"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
@@ -10,6 +10,7 @@ lsp-types = { version = "0.73.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
 serde_json = "1.0.48"
+jod-thread = "0.1.1"
 [dev-dependencies]
 insta = "0.15.0"
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_flycheck/src/conv.rs
index 817543deb..817543deb 100644
--- a/crates/ra_cargo_watch/src/conv.rs
+++ b/crates/ra_flycheck/src/conv.rs
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap
index a59fa84fa..4c9db0385 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap
index 61ae0c9ae..7cde4d867 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap
index 641da1a58..1cc37e087 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap
index 0557a2e79..615ed8378 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap
index 754bc33a4..0df0fce18 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap
index 78b7f7cc8..28ebcb3b3 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap
index 5989ed202..5e0873281 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap
index e34b546dc..e500d3cd6 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/test.rs b/crates/ra_flycheck/src/conv/test.rs
index 4e81455ca..4e81455ca 100644
--- a/crates/ra_cargo_watch/src/conv/test.rs
+++ b/crates/ra_flycheck/src/conv/test.rs
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index 7c525c430..75aece45f 100644
--- a/crates/ra_cargo_watch/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -1,85 +1,60 @@
 //! cargo_check provides the functionality needed to run `cargo check` or
 //! another compatible command (f.x. clippy) in a background thread and provide
 //! LSP diagnostics based on the output of the command.
-use cargo_metadata::Message;
+mod conv;
-use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
-use lsp_types::{
-    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
-    WorkDoneProgressEnd, WorkDoneProgressReport,
-};
 use std::{
    error, fmt,
    io::{BufRead, BufReader},
    path::{Path, PathBuf},
    process::{Command, Stdio},
-    thread::JoinHandle,
    time::Instant,
 };
-mod conv;
+use cargo_metadata::Message;
+use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
+use lsp_types::{
+    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
+    WorkDoneProgressEnd, WorkDoneProgressReport,
+};
 use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
 pub use crate::conv::url_from_path_with_drive_lowercasing;
 #[derive(Clone, Debug)]
-pub struct CheckOptions {
+pub struct CheckConfig {
-    pub enable: bool,
    pub args: Vec<String>,
    pub command: String,
    pub all_targets: bool,
 }
-/// CheckWatcher wraps the shared state and communication machinery used for
+/// Flycheck wraps the shared state and communication machinery used for
 /// running `cargo check` (or other compatible command) and providing
 /// diagnostics based on the output.
 /// The spawned thread is shut down when this struct is dropped.
 #[derive(Debug)]
-pub struct CheckWatcher {
+pub struct Flycheck {
+    // XXX: drop order is significant
+    cmd_send: Sender<CheckCommand>,
+    handle: jod_thread::JoinHandle<()>,
    pub task_recv: Receiver<CheckTask>,
-    cmd_send: Option<Sender<CheckCommand>>,
-    handle: Option<JoinHandle<()>>,
 }
-impl CheckWatcher {
+impl Flycheck {
-    pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
+    pub fn new(config: CheckConfig, workspace_root: PathBuf) -> Flycheck {
-        let options = options.clone();
        let (task_send, task_recv) = unbounded::<CheckTask>();
        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
-        let handle = std::thread::spawn(move || {
+        let handle = jod_thread::spawn(move || {
-            let mut check = CheckWatcherThread::new(options, workspace_root);
+            let mut check = FlycheckThread::new(config, workspace_root);
            check.run(&task_send, &cmd_recv);
        });
-        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle) }
+        Flycheck { task_recv, cmd_send, handle }
-    }
-    /// Returns a CheckWatcher that doesn't actually do anything
-    pub fn dummy() -> CheckWatcher {
-        CheckWatcher { task_recv: never(), cmd_send: None, handle: None }
    }
    /// Schedule a re-start of the cargo check worker.
    pub fn update(&self) {
-        if let Some(cmd_send) = &self.cmd_send {
+        self.cmd_send.send(CheckCommand::Update).unwrap();
-            cmd_send.send(CheckCommand::Update).unwrap();
-        }
-    }
-}
-impl std::ops::Drop for CheckWatcher {
-    fn drop(&mut self) {
-        if let Some(handle) = self.handle.take() {
-            // Take the sender out of the option
-            let cmd_send = self.cmd_send.take();
-            // Dropping the sender finishes the thread loop
-            drop(cmd_send);
-            // Join the thread, it should finish shortly. We don't really care
-            // whether it panicked, so it is safe to ignore the result
-            let _ = handle.join();
-        }
    }
 }
@@ -100,24 +75,35 @@ pub enum CheckCommand {
    Update,
 }
-struct CheckWatcherThread {
+struct FlycheckThread {
-    options: CheckOptions,
+    options: CheckConfig,
    workspace_root: PathBuf,
-    watcher: WatchThread,
    last_update_req: Option<Instant>,
+    // XXX: drop order is significant
+    message_recv: Receiver<CheckEvent>,
+    /// WatchThread exists to wrap around the communication needed to be able to
+    /// run `cargo check` without blocking. Currently the Rust standard library
+    /// doesn't provide a way to read sub-process output without blocking, so we
+    /// have to wrap sub-processes output handling in a thread and pass messages
+    /// back over a channel.
+    check_process: Option<jod_thread::JoinHandle<()>>,
 }
-impl CheckWatcherThread {
+impl FlycheckThread {
-    fn new(options: CheckOptions, workspace_root: PathBuf) -> CheckWatcherThread {
+    fn new(options: CheckConfig, workspace_root: PathBuf) -> FlycheckThread {
-        CheckWatcherThread {
+        FlycheckThread {
            options,
            workspace_root,
-            watcher: WatchThread::dummy(),
            last_update_req: None,
+            message_recv: never(),
+            check_process: None,
        }
    }
    fn run(&mut self, task_send: &Sender<CheckTask>, cmd_recv: &Receiver<CheckCommand>) {
+        // If we rerun the thread, we need to discard the previous check results first
+        self.clean_previous_results(task_send);
        loop {
            select! {
                recv(&cmd_recv) -> cmd => match cmd {
@@ -127,29 +113,32 @@ impl CheckWatcherThread {
                        break;
                    },
                },
-                recv(self.watcher.message_recv) -> msg => match msg {
+                recv(self.message_recv) -> msg => match msg {
                    Ok(msg) => self.handle_message(msg, task_send),
                    Err(RecvError) => {
                        // Watcher finished, replace it with a never channel to
                        // avoid busy-waiting.
-                        std::mem::replace(&mut self.watcher.message_recv, never());
+                        self.message_recv = never();
+                        self.check_process = None;
                    },
                }
            };
            if self.should_recheck() {
-                self.last_update_req.take();
+                self.last_update_req = None;
                task_send.send(CheckTask::ClearDiagnostics).unwrap();
+                self.restart_check_process();
-                // Replace with a dummy watcher first so we drop the original and wait for completion
-                std::mem::replace(&mut self.watcher, WatchThread::dummy());
-                // Then create the actual new watcher
-                self.watcher = WatchThread::new(&self.options, &self.workspace_root);
            }
        }
    }
+    fn clean_previous_results(&self, task_send: &Sender<CheckTask>) {
+        task_send.send(CheckTask::ClearDiagnostics).unwrap();
+        task_send
+            .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd { message: None })))
+            .unwrap();
+    }
    fn should_recheck(&mut self) -> bool {
        if let Some(_last_update_req) = &self.last_update_req {
            // We currently only request an update on save, as we need up to
@@ -221,6 +210,56 @@ impl CheckWatcherThread {
            CheckEvent::Msg(Message::Unknown) => {}
        }
    }
+    fn restart_check_process(&mut self) {
+        // First, clear and cancel the old thread
+        self.message_recv = never();
+        self.check_process = None;
+        let mut args: Vec<String> = vec![
+            self.options.command.clone(),
+            "--workspace".to_string(),
+            "--message-format=json".to_string(),
+            "--manifest-path".to_string(),
+            format!("{}/Cargo.toml", self.workspace_root.display()),
+        ];
+        if self.options.all_targets {
+            args.push("--all-targets".to_string());
+        }
+        args.extend(self.options.args.iter().cloned());
+        let (message_send, message_recv) = unbounded();
+        let workspace_root = self.workspace_root.to_owned();
+        self.message_recv = message_recv;
+        self.check_process = Some(jod_thread::spawn(move || {
+            // If we trigger an error here, we will do so in the loop instead,
+            // which will break out of the loop, and continue the shutdown
+            let _ = message_send.send(CheckEvent::Begin);
+            let res = run_cargo(&args, Some(&workspace_root), &mut |message| {
+                // Skip certain kinds of messages to only spend time on what's useful
+                match &message {
+                    Message::CompilerArtifact(artifact) if artifact.fresh => return true,
+                    Message::BuildScriptExecuted(_) => return true,
+                    Message::Unknown => return true,
+                    _ => {}
+                }
+                // if the send channel was closed, we want to shutdown
+                message_send.send(CheckEvent::Msg(message)).is_ok()
+            });
+            if let Err(err) = res {
+                // FIXME: make the `message_send` to be `Sender<Result<CheckEvent, CargoError>>`
+                // to display user-caused misconfiguration errors instead of just logging them here
+                log::error!("Cargo watcher failed {:?}", err);
+            }
+            // We can ignore any error here, as we are already in the progress
+            // of shutting down.
+            let _ = message_send.send(CheckEvent::End);
+        }))
+    }
 }
 #[derive(Debug)]
@@ -229,18 +268,6 @@ pub struct DiagnosticWithFixes {
    fixes: Vec<CodeAction>,
 }
-/// WatchThread exists to wrap around the communication needed to be able to
-/// run `cargo check` without blocking. Currently the Rust standard library
-/// doesn't provide a way to read sub-process output without blocking, so we
-/// have to wrap sub-processes output handling in a thread and pass messages
-/// back over a channel.
-/// The correct way to dispose of the thread is to drop it, on which the
-/// sub-process will be killed, and the thread will be joined.
-struct WatchThread {
-    handle: Option<JoinHandle<()>>,
-    message_recv: Receiver<CheckEvent>,
-}
 enum CheckEvent {
    Begin,
    Msg(cargo_metadata::Message),
@@ -257,7 +284,7 @@ impl fmt::Display for CargoError {
 }
 impl error::Error for CargoError {}
-pub fn run_cargo(
+fn run_cargo(
    args: &[String],
    current_dir: Option<&Path>,
    on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
@@ -330,76 +357,3 @@ pub fn run_cargo(
    Err(CargoError(err_msg))
 }
-impl WatchThread {
-    fn dummy() -> WatchThread {
-        WatchThread { handle: None, message_recv: never() }
-    }
-    fn new(options: &CheckOptions, workspace_root: &Path) -> WatchThread {
-        let mut args: Vec<String> = vec![
-            options.command.clone(),
-            "--workspace".to_string(),
-            "--message-format=json".to_string(),
-            "--manifest-path".to_string(),
-            format!("{}/Cargo.toml", workspace_root.display()),
-        ];
-        if options.all_targets {
-            args.push("--all-targets".to_string());
-        }
-        args.extend(options.args.iter().cloned());
-        let (message_send, message_recv) = unbounded();
-        let workspace_root = workspace_root.to_owned();
-        let handle = if options.enable {
-            Some(std::thread::spawn(move || {
-                // If we trigger an error here, we will do so in the loop instead,
-                // which will break out of the loop, and continue the shutdown
-                let _ = message_send.send(CheckEvent::Begin);
-                let res = run_cargo(&args, Some(&workspace_root), &mut |message| {
-                    // Skip certain kinds of messages to only spend time on what's useful
-                    match &message {
-                        Message::CompilerArtifact(artifact) if artifact.fresh => return true,
-                        Message::BuildScriptExecuted(_) => return true,
-                        Message::Unknown => return true,
-                        _ => {}
-                    }
-                    // if the send channel was closed, we want to shutdown
-                    message_send.send(CheckEvent::Msg(message)).is_ok()
-                });
-                if let Err(err) = res {
-                    // FIXME: make the `message_send` to be `Sender<Result<CheckEvent, CargoError>>`
-                    // to display user-caused misconfiguration errors instead of just logging them here
-                    log::error!("Cargo watcher failed {:?}", err);
-                }
-                // We can ignore any error here, as we are already in the progress
-                // of shutting down.
-                let _ = message_send.send(CheckEvent::End);
-            }))
-        } else {
-            None
-        };
-        WatchThread { handle, message_recv }
-    }
-}
-impl std::ops::Drop for WatchThread {
-    fn drop(&mut self) {
-        if let Some(handle) = self.handle.take() {
-            // Replace our reciever with dummy one, so we can drop and close the
-            // one actually communicating with the thread
-            let recv = std::mem::replace(&mut self.message_recv, never());
-            // Dropping the original reciever initiates thread sub-process shutdown
-            drop(recv);
-            // Join the thread, it should finish shortly. We don't really care
-            // whether it panicked, so it is safe to ignore the result
-            let _ = handle.join();
-        }
-    }
-}
diff --git a/crates/ra_hir_expand/src/proc_macro.rs b/crates/ra_hir_expand/src/proc_macro.rs
index 4d270e0de..97d1208ec 100644
--- a/crates/ra_hir_expand/src/proc_macro.rs
+++ b/crates/ra_hir_expand/src/proc_macro.rs
@@ -9,6 +9,15 @@ pub struct ProcMacroExpander {
    proc_macro_id: ProcMacroId,
 }
+macro_rules! err {
+    ($fmt:literal, $($tt:tt),*) => {
+        mbe::ExpandError::ProcMacroError(tt::ExpansionError::Unknown(format!($fmt, $($tt),*)))
+    };
+    ($fmt:literal) => {
+        mbe::ExpandError::ProcMacroError(tt::ExpansionError::Unknown($fmt.to_string()))
+    }
+}
 impl ProcMacroExpander {
    pub fn new(krate: CrateId, proc_macro_id: ProcMacroId) -> ProcMacroExpander {
        ProcMacroExpander { krate, proc_macro_id }
@@ -25,8 +34,24 @@ impl ProcMacroExpander {
            .proc_macro
            .get(self.proc_macro_id.0 as usize)
            .clone()
-            .ok_or_else(|| mbe::ExpandError::ConversionError)?;
+            .ok_or_else(|| err!("No derive macro found."))?;
+        let tt = remove_derive_atr(tt, &proc_macro.name)
+            .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
        proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
    }
 }
+fn remove_derive_atr(tt: &tt::Subtree, _name: &str) -> Option<tt::Subtree> {
+    // FIXME: proper handle the remove derive
+    // We assume the first 2 tokens are #[derive(name)]
+    if tt.token_trees.len() > 2 {
+        let mut tt = tt.clone();
+        tt.token_trees.remove(0);
+        tt.token_trees.remove(0);
+        return Some(tt);
+    }
+    None
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index a6ef44a31..13ecd537a 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -159,20 +159,13 @@ impl HirDisplay for ApplicationTy {
            }
            TypeCtor::FnDef(def) => {
                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
-                let name = match def {
+                match def {
-                    CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
+                    CallableDef::FunctionId(ff) => write!(f, "fn {}", f.db.function_data(ff).name)?,
-                    CallableDef::StructId(s) => f.db.struct_data(s).name.clone(),
+                    CallableDef::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?,
                    CallableDef::EnumVariantId(e) => {
-                        let enum_data = f.db.enum_data(e.parent);
+                        write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)?
-                        enum_data.variants[e.local_id].name.clone()
                    }
                };
-                match def {
-                    CallableDef::FunctionId(_) => write!(f, "fn {}", name)?,
-                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {
-                        write!(f, "{}", name)?
-                    }
-                }
                if self.parameters.len() > 0 {
                    let generics = generics(f.db.upcast(), def.into());
                    let (parent_params, self_param, type_params, _impl_trait_params) =
@@ -197,8 +190,6 @@ impl HirDisplay for ApplicationTy {
                };
                write!(f, "{}", name)?;
                if self.parameters.len() > 0 {
-                    write!(f, "<")?;
                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
                    let parameters_to_write = if f.omit_verbose_types() {
                        match self
@@ -207,8 +198,8 @@ impl HirDisplay for ApplicationTy {
                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                            .filter(|defaults| !defaults.is_empty())
                        {
-                            Option::None => self.parameters.0.as_ref(),
+                            None => self.parameters.0.as_ref(),
-                            Option::Some(default_parameters) => {
+                            Some(default_parameters) => {
                                for (i, parameter) in self.parameters.iter().enumerate() {
                                    match (parameter, default_parameters.get(i)) {
                                        (&Ty::Unknown, _) | (_, None) => {
@@ -228,7 +219,7 @@ impl HirDisplay for ApplicationTy {
                    } else {
                        self.parameters.0.as_ref()
                    };
+                    write!(f, "<")?;
                    f.write_joined(parameters_to_write, ", ")?;
                    write!(f, ">")?;
                }
@@ -238,9 +229,9 @@ impl HirDisplay for ApplicationTy {
                    AssocContainerId::TraitId(it) => it,
                    _ => panic!("not an associated type"),
                };
-                let trait_name = f.db.trait_data(trait_).name.clone();
+                let trait_ = f.db.trait_data(trait_);
-                let name = f.db.type_alias_data(type_alias).name.clone();
+                let type_alias = f.db.type_alias_data(type_alias);
-                write!(f, "{}::{}", trait_name, name)?;
+                write!(f, "{}::{}", trait_.name, type_alias.name)?;
                if self.parameters.len() > 0 {
                    write!(f, "<")?;
                    f.write_joined(&*self.parameters.0, ", ")?;
@@ -273,8 +264,8 @@ impl HirDisplay for ProjectionTy {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        let trait_name = f.db.trait_data(self.trait_(f.db)).name.clone();
+        let trait_ = f.db.trait_data(self.trait_(f.db));
-        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_name,)?;
+        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_.name)?;
        if self.parameters.len() > 1 {
            write!(f, "<")?;
            f.write_joined(&self.parameters[1..], ", ")?;
@@ -319,7 +310,7 @@ impl HirDisplay for Ty {
                    Ty::Opaque(_) => write!(f, "impl ")?,
                    _ => unreachable!(),
                };
-                write_bounds_like_dyn_trait(&predicates, f)?;
+                write_bounds_like_dyn_trait(predicates, f)?;
            }
            Ty::Unknown => write!(f, "{{unknown}}")?,
            Ty::Infer(..) => write!(f, "_")?,
@@ -352,7 +343,7 @@ fn write_bounds_like_dyn_trait(
                // We assume that the self type is $0 (i.e. the
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
-                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
+                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name)?;
                if trait_ref.substs.len() > 1 {
                    write!(f, "<")?;
                    f.write_joined(&trait_ref.substs[1..], ", ")?;
@@ -369,9 +360,8 @@ fn write_bounds_like_dyn_trait(
                    write!(f, "<")?;
                    angle_open = true;
                }
-                let name =
+                let type_alias = f.db.type_alias_data(projection_pred.projection_ty.associated_ty);
-                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name.clone();
+                write!(f, "{} = ", type_alias.name)?;
-                write!(f, "{} = ", name)?;
                projection_pred.ty.hir_fmt(f)?;
            }
            GenericPredicate::Error => {
@@ -405,7 +395,7 @@ impl TraitRef {
        } else {
            write!(f, ": ")?;
        }
-        write!(f, "{}", f.db.trait_data(self.trait_).name.clone())?;
+        write!(f, "{}", f.db.trait_data(self.trait_).name)?;
        if self.substs.len() > 1 {
            write!(f, "<")?;
            f.write_joined(&self.substs[1..], ", ")?;
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index cd0757be5..b683572fb 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -34,15 +34,15 @@ pub use crate::completion::completion_item::{
 };
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CompletionOptions {
+pub struct CompletionConfig {
    pub enable_postfix_completions: bool,
    pub add_call_parenthesis: bool,
    pub add_call_argument_snippets: bool,
 }
-impl Default for CompletionOptions {
+impl Default for CompletionConfig {
    fn default() -> Self {
-        CompletionOptions {
+        CompletionConfig {
            enable_postfix_completions: true,
            add_call_parenthesis: true,
            add_call_argument_snippets: true,
@@ -75,9 +75,9 @@ impl Default for CompletionOptions {
 pub(crate) fn completions(
    db: &RootDatabase,
    position: FilePosition,
-    options: &CompletionOptions,
+    config: &CompletionConfig,
 ) -> Option<Completions> {
-    let ctx = CompletionContext::new(db, position, options)?;
+    let ctx = CompletionContext::new(db, position, config)?;
    let mut acc = Completions::default();
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 0a00054b2..29c2881c6 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -15,7 +15,7 @@ use crate::{
 };
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.options.enable_postfix_completions {
+    if !ctx.config.enable_postfix_completions {
        return;
    }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 319e33b61..fdc0da2c5 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
-use crate::{completion::CompletionOptions, FilePosition};
+use crate::{completion::CompletionConfig, FilePosition};
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -19,7 +19,7 @@ use crate::{completion::CompletionOptions, FilePosition};
 pub(crate) struct CompletionContext<'a> {
    pub(super) sema: Semantics<'a, RootDatabase>,
    pub(super) db: &'a RootDatabase,
-    pub(super) options: &'a CompletionOptions,
+    pub(super) config: &'a CompletionConfig,
    pub(super) offset: TextUnit,
    /// The token before the cursor, in the original file.
    pub(super) original_token: SyntaxToken,
@@ -61,7 +61,7 @@ impl<'a> CompletionContext<'a> {
    pub(super) fn new(
        db: &'a RootDatabase,
        position: FilePosition,
-        options: &'a CompletionOptions,
+        config: &'a CompletionConfig,
    ) -> Option<CompletionContext<'a>> {
        let sema = Semantics::new(db);
@@ -85,7 +85,7 @@ impl<'a> CompletionContext<'a> {
        let mut ctx = CompletionContext {
            sema,
            db,
-            options,
+            config,
            original_token,
            token,
            offset: position.offset,
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 60f1b83f3..1c7c0924d 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -106,7 +106,7 @@ impl Completions {
        };
        // Add `<>` for generic types
-        if ctx.is_path_type && !ctx.has_type_args && ctx.options.add_call_parenthesis {
+        if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
            let has_non_default_type_params = match resolution {
                ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
                ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
@@ -211,14 +211,14 @@ impl Completions {
                .detail(function_signature.to_string());
        // If not an import, add parenthesis automatically.
-        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.options.add_call_parenthesis {
+        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.config.add_call_parenthesis {
            tested_by!(inserts_parens_for_function_calls);
            let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
                (format!("{}()$0", name), format!("{}()", name))
            } else {
                builder = builder.trigger_call_info();
-                let snippet = if ctx.options.add_call_argument_snippets {
+                let snippet = if ctx.config.add_call_argument_snippets {
                    let to_skip = if has_self_param { 1 } else { 0 };
                    let function_params_snippet = function_signature
                        .parameter_names
@@ -311,7 +311,7 @@ mod tests {
    use crate::completion::{
        test_utils::{do_completion, do_completion_with_options},
-        CompletionItem, CompletionKind, CompletionOptions,
+        CompletionConfig, CompletionItem, CompletionKind,
    };
    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
@@ -320,7 +320,7 @@ mod tests {
    fn do_reference_completion_with_options(
        ra_fixture: &str,
-        options: CompletionOptions,
+        options: CompletionConfig,
    ) -> Vec<CompletionItem> {
        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options)
    }
@@ -589,7 +589,7 @@ mod tests {
                    s.f<|>
                }
                ",
-                CompletionOptions {
+                CompletionConfig {
                    add_call_argument_snippets: false,
                    .. Default::default()
                }
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index 136857315..eb90b5279 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -1,19 +1,19 @@
 //! Runs completion for testing purposes.
 use crate::{
-    completion::{completion_item::CompletionKind, CompletionOptions},
+    completion::{completion_item::CompletionKind, CompletionConfig},
    mock_analysis::{analysis_and_position, single_file_with_position},
    CompletionItem,
 };
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    do_completion_with_options(code, kind, &CompletionOptions::default())
+    do_completion_with_options(code, kind, &CompletionConfig::default())
 }
 pub(crate) fn do_completion_with_options(
    code: &str,
    kind: CompletionKind,
-    options: &CompletionOptions,
+    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
    let (analysis, position) = if code.contains("//-") {
        analysis_and_position(code)
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index f4f0751c0..d06fc03d3 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -11,14 +11,14 @@ use ra_syntax::{
 use crate::{FileId, FunctionSignature};
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct InlayHintsOptions {
+pub struct InlayHintsConfig {
    pub type_hints: bool,
    pub parameter_hints: bool,
    pub chaining_hints: bool,
    pub max_length: Option<usize>,
 }
-impl Default for InlayHintsOptions {
+impl Default for InlayHintsConfig {
    fn default() -> Self {
        Self { type_hints: true, parameter_hints: true, chaining_hints: true, max_length: None }
    }
@@ -41,7 +41,7 @@ pub struct InlayHint {
 pub(crate) fn inlay_hints(
    db: &RootDatabase,
    file_id: FileId,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
 ) -> Vec<InlayHint> {
    let _p = profile("inlay_hints");
    let sema = Semantics::new(db);
@@ -50,14 +50,14 @@ pub(crate) fn inlay_hints(
    let mut res = Vec::new();
    for node in file.syntax().descendants() {
        if let Some(expr) = ast::Expr::cast(node.clone()) {
-            get_chaining_hints(&mut res, &sema, options, expr);
+            get_chaining_hints(&mut res, &sema, config, expr);
        }
        match_ast! {
            match node {
-                ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
+                ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); },
-                ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
+                ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); },
-                ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, options, it); },
+                ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, config, it); },
                _ => (),
            }
        }
@@ -68,10 +68,10 @@ pub(crate) fn inlay_hints(
 fn get_chaining_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    expr: ast::Expr,
 ) -> Option<()> {
-    if !options.chaining_hints {
+    if !config.chaining_hints {
        return None;
    }
@@ -95,7 +95,7 @@ fn get_chaining_hints(
    let next = tokens.next()?.kind();
    let next_next = tokens.next()?.kind();
    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
-        let label = ty.display_truncated(sema.db, options.max_length).to_string();
+        let label = ty.display_truncated(sema.db, config.max_length).to_string();
        acc.push(InlayHint {
            range: expr.syntax().text_range(),
            kind: InlayKind::ChainingHint,
@@ -108,10 +108,10 @@ fn get_chaining_hints(
 fn get_param_name_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    expr: ast::Expr,
 ) -> Option<()> {
-    if !options.parameter_hints {
+    if !config.parameter_hints {
        return None;
    }
@@ -148,10 +148,10 @@ fn get_param_name_hints(
 fn get_bind_pat_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    pat: ast::BindPat,
 ) -> Option<()> {
-    if !options.type_hints {
+    if !config.type_hints {
        return None;
    }
@@ -164,7 +164,7 @@ fn get_bind_pat_hints(
    acc.push(InlayHint {
        range: pat.syntax().text_range(),
        kind: InlayKind::TypeHint,
-        label: ty.display_truncated(sema.db, options.max_length).to_string().into(),
+        label: ty.display_truncated(sema.db, config.max_length).to_string().into(),
    });
    Some(())
 }
@@ -270,7 +270,7 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
 #[cfg(test)]
 mod tests {
-    use crate::inlay_hints::InlayHintsOptions;
+    use crate::inlay_hints::InlayHintsConfig;
    use insta::assert_debug_snapshot;
    use crate::mock_analysis::single_file;
@@ -284,7 +284,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [106; 107),
@@ -308,7 +308,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
@@ -320,7 +320,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [97; 99),
@@ -344,7 +344,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [69; 71),
@@ -401,7 +401,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [193; 197),
@@ -481,7 +481,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [21; 30),
@@ -545,7 +545,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [21; 30),
@@ -595,7 +595,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [188; 192),
@@ -690,7 +690,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [188; 192),
@@ -785,7 +785,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [252; 256),
@@ -857,7 +857,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        [
            InlayHint {
                range: [74; 75),
@@ -945,7 +945,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [798; 809),
@@ -1067,7 +1067,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        []
        "###
        );
@@ -1093,7 +1093,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        []
        "###
        );
@@ -1115,7 +1115,7 @@ fn main() {
                    .into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [232; 269),
@@ -1144,7 +1144,7 @@ fn main() {
                let c = A(B(C)).into_b().into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
@@ -1162,7 +1162,7 @@ fn main() {
                    .0;
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [150; 221),
@@ -1204,7 +1204,7 @@ fn main() {
                    .into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [403; 452),
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index e43414985..285381086 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -62,13 +62,13 @@ use crate::display::ToNav;
 pub use crate::{
    assists::{Assist, AssistId},
    call_hierarchy::CallItem,
-    completion::{CompletionItem, CompletionItemKind, CompletionOptions, InsertTextFormat},
+    completion::{CompletionConfig, CompletionItem, CompletionItemKind, InsertTextFormat},
    diagnostics::Severity,
    display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
    expand_macro::ExpandedMacro,
    folding_ranges::{Fold, FoldKind},
    hover::HoverResult,
-    inlay_hints::{InlayHint, InlayHintsOptions, InlayKind},
+    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
@@ -138,6 +138,11 @@ impl AnalysisHost {
    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
        AnalysisHost { db: RootDatabase::new(lru_capacity) }
    }
+    pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
+        self.db.update_lru_capacity(lru_capacity);
+    }
    /// Returns a snapshot of the current state, which you can query for
    /// semantic information.
    pub fn analysis(&self) -> Analysis {
@@ -320,9 +325,9 @@ impl Analysis {
    pub fn inlay_hints(
        &self,
        file_id: FileId,
-        inlay_hint_opts: &InlayHintsOptions,
+        config: &InlayHintsConfig,
    ) -> Cancelable<Vec<InlayHint>> {
-        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, inlay_hint_opts))
+        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, config))
    }
    /// Returns the set of folding ranges.
@@ -445,9 +450,9 @@ impl Analysis {
    pub fn completions(
        &self,
        position: FilePosition,
-        options: &CompletionOptions,
+        config: &CompletionConfig,
    ) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.with_db(|db| completion::completions(db, position, options).map(Into::into))
+        self.with_db(|db| completion::completions(db, position, config).map(Into::into))
    }
    /// Computes assists (aka code actions aka intentions) for the given
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index 4faeefa8d..e6f2d36e9 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -115,12 +115,16 @@ impl RootDatabase {
        db.set_crate_graph_with_durability(Default::default(), Durability::HIGH);
        db.set_local_roots_with_durability(Default::default(), Durability::HIGH);
        db.set_library_roots_with_durability(Default::default(), Durability::HIGH);
-        let lru_capacity = lru_capacity.unwrap_or(ra_db::DEFAULT_LRU_CAP);
+        db.update_lru_capacity(lru_capacity);
-        db.query_mut(ra_db::ParseQuery).set_lru_capacity(lru_capacity);
-        db.query_mut(hir::db::ParseMacroQuery).set_lru_capacity(lru_capacity);
-        db.query_mut(hir::db::MacroExpandQuery).set_lru_capacity(lru_capacity);
        db
    }
+    pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
+        let lru_capacity = lru_capacity.unwrap_or(ra_db::DEFAULT_LRU_CAP);
+        self.query_mut(ra_db::ParseQuery).set_lru_capacity(lru_capacity);
+        self.query_mut(hir::db::ParseMacroQuery).set_lru_capacity(lru_capacity);
+        self.query_mut(hir::db::MacroExpandQuery).set_lru_capacity(lru_capacity);
+    }
 }
 impl salsa::ParallelDatabase for RootDatabase {
diff --git a/crates/ra_proc_macro/Cargo.toml b/crates/ra_proc_macro/Cargo.toml
index bc2c37296..d009ceb82 100644
--- a/crates/ra_proc_macro/Cargo.toml
+++ b/crates/ra_proc_macro/Cargo.toml
@@ -10,3 +10,8 @@ doctest = false
 [dependencies]
 ra_tt = { path = "../ra_tt" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+log = "0.4.8"
+crossbeam-channel = "0.4.0"
+jod-thread = "0.1.1"
diff --git a/crates/ra_proc_macro/src/lib.rs b/crates/ra_proc_macro/src/lib.rs
index 5e21dd487..51fbb046a 100644
--- a/crates/ra_proc_macro/src/lib.rs
+++ b/crates/ra_proc_macro/src/lib.rs
@@ -5,55 +5,104 @@
 //! is used to provide basic infrastructure  for communication between two
 //! processes: Client (RA itself), Server (the external program)
+mod rpc;
+mod process;
+pub mod msg;
+use process::{ProcMacroProcessSrv, ProcMacroProcessThread};
 use ra_tt::{SmolStr, Subtree};
+use rpc::ProcMacroKind;
 use std::{
    path::{Path, PathBuf},
    sync::Arc,
 };
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub use rpc::{ExpansionResult, ExpansionTask};
+#[derive(Debug, Clone)]
 pub struct ProcMacroProcessExpander {
    process: Arc<ProcMacroProcessSrv>,
+    dylib_path: PathBuf,
    name: SmolStr,
 }
+impl Eq for ProcMacroProcessExpander {}
+impl PartialEq for ProcMacroProcessExpander {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+            && self.dylib_path == other.dylib_path
+            && Arc::ptr_eq(&self.process, &other.process)
+    }
+}
 impl ra_tt::TokenExpander for ProcMacroProcessExpander {
    fn expand(
        &self,
-        _subtree: &Subtree,
+        subtree: &Subtree,
        _attr: Option<&Subtree>,
    ) -> Result<Subtree, ra_tt::ExpansionError> {
-        // FIXME: do nothing for now
+        self.process.custom_derive(&self.dylib_path, subtree, &self.name)
-        Ok(Subtree::default())
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
-pub struct ProcMacroProcessSrv {
+enum ProcMacroClientKind {
-    path: PathBuf,
+    Process { process: Arc<ProcMacroProcessSrv>, thread: ProcMacroProcessThread },
+    Dummy,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
-pub enum ProcMacroClient {
+pub struct ProcMacroClient {
-    Process { process: Arc<ProcMacroProcessSrv> },
+    kind: ProcMacroClientKind,
-    Dummy,
 }
 impl ProcMacroClient {
-    pub fn extern_process(process_path: &Path) -> ProcMacroClient {
+    pub fn extern_process(process_path: &Path) -> Result<ProcMacroClient, std::io::Error> {
-        let process = ProcMacroProcessSrv { path: process_path.into() };
+        let (thread, process) = ProcMacroProcessSrv::run(process_path)?;
-        ProcMacroClient::Process { process: Arc::new(process) }
+        Ok(ProcMacroClient {
+            kind: ProcMacroClientKind::Process { process: Arc::new(process), thread },
+        })
    }
    pub fn dummy() -> ProcMacroClient {
-        ProcMacroClient::Dummy
+        ProcMacroClient { kind: ProcMacroClientKind::Dummy }
    }
    pub fn by_dylib_path(
        &self,
-        _dylib_path: &Path,
+        dylib_path: &Path,
    ) -> Vec<(SmolStr, Arc<dyn ra_tt::TokenExpander>)> {
-        // FIXME: return empty for now
+        match &self.kind {
-        vec![]
+            ProcMacroClientKind::Dummy => vec![],
+            ProcMacroClientKind::Process { process, .. } => {
+                let macros = match process.find_proc_macros(dylib_path) {
+                    Err(err) => {
+                        eprintln!("Fail to find proc macro. Error: {:#?}", err);
+                        return vec![];
+                    }
+                    Ok(macros) => macros,
+                };
+                macros
+                    .into_iter()
+                    .filter_map(|(name, kind)| {
+                        // FIXME: Support custom derive only for now.
+                        match kind {
+                            ProcMacroKind::CustomDerive => {
+                                let name = SmolStr::new(&name);
+                                let expander: Arc<dyn ra_tt::TokenExpander> =
+                                    Arc::new(ProcMacroProcessExpander {
+                                        process: process.clone(),
+                                        name: name.clone(),
+                                        dylib_path: dylib_path.into(),
+                                    });
+                                Some((name, expander))
+                            }
+                            _ => None,
+                        }
+                    })
+                    .collect()
+            }
+        }
    }
 }
diff --git a/crates/ra_proc_macro/src/msg.rs b/crates/ra_proc_macro/src/msg.rs
new file mode 100644
index 000000000..aa95bcc8f
--- /dev/null
+++ b/crates/ra_proc_macro/src/msg.rs
@@ -0,0 +1,93 @@
+//! Defines messages for cross-process message based on `ndjson` wire protocol
+use std::{
+    convert::TryFrom,
+    io::{self, BufRead, Write},
+};
+use crate::{
+    rpc::{ListMacrosResult, ListMacrosTask},
+    ExpansionResult, ExpansionTask,
+};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum Request {
+    ListMacro(ListMacrosTask),
+    ExpansionMacro(ExpansionTask),
+}
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum Response {
+    Error(ResponseError),
+    ListMacro(ListMacrosResult),
+    ExpansionMacro(ExpansionResult),
+}
+macro_rules! impl_try_from_response {
+    ($ty:ty, $tag:ident) => {
+        impl TryFrom<Response> for $ty {
+            type Error = &'static str;
+            fn try_from(value: Response) -> Result<Self, Self::Error> {
+                match value {
+                    Response::$tag(res) => Ok(res),
+                    _ => Err("Fail to convert from response"),
+                }
+            }
+        }
+    };
+}
+impl_try_from_response!(ListMacrosResult, ListMacro);
+impl_try_from_response!(ExpansionResult, ExpansionMacro);
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ResponseError {
+    pub code: ErrorCode,
+    pub message: String,
+}
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum ErrorCode {
+    ServerErrorEnd,
+    ExpansionError,
+}
+pub trait Message: Sized + Serialize + DeserializeOwned {
+    fn read(r: &mut impl BufRead) -> io::Result<Option<Self>> {
+        let text = match read_json(r)? {
+            None => return Ok(None),
+            Some(text) => text,
+        };
+        let msg = serde_json::from_str(&text)?;
+        Ok(Some(msg))
+    }
+    fn write(self, w: &mut impl Write) -> io::Result<()> {
+        let text = serde_json::to_string(&self)?;
+        write_json(w, &text)
+    }
+}
+impl Message for Request {}
+impl Message for Response {}
+fn read_json(inp: &mut impl BufRead) -> io::Result<Option<String>> {
+    let mut buf = String::new();
+    if inp.read_line(&mut buf)? == 0 {
+        return Ok(None);
+    }
+    // Remove ending '\n'
+    let buf = &buf[..buf.len() - 1];
+    if buf.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(buf.to_string()))
+}
+fn write_json(out: &mut impl Write, msg: &str) -> io::Result<()> {
+    log::debug!("> {}", msg);
+    out.write_all(msg.as_bytes())?;
+    out.write_all(b"\n")?;
+    out.flush()?;
+    Ok(())
+}
diff --git a/crates/ra_proc_macro/src/process.rs b/crates/ra_proc_macro/src/process.rs
new file mode 100644
index 000000000..e8c85be38
--- /dev/null
+++ b/crates/ra_proc_macro/src/process.rs
@@ -0,0 +1,196 @@
+//! Handle process life-time and message passing for proc-macro client
+use crossbeam_channel::{bounded, Receiver, Sender};
+use ra_tt::Subtree;
+use crate::msg::{ErrorCode, Message, Request, Response, ResponseError};
+use crate::rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
+use io::{BufRead, BufReader};
+use std::{
+    convert::{TryFrom, TryInto},
+    io::{self, Write},
+    path::{Path, PathBuf},
+    process::{Child, Command, Stdio},
+    sync::{Arc, Weak},
+};
+#[derive(Debug, Default)]
+pub(crate) struct ProcMacroProcessSrv {
+    inner: Option<Weak<Sender<Task>>>,
+}
+#[derive(Debug)]
+pub(crate) struct ProcMacroProcessThread {
+    // XXX: drop order is significant
+    sender: Arc<Sender<Task>>,
+    handle: jod_thread::JoinHandle<()>,
+}
+struct Task {
+    req: Request,
+    result_tx: Sender<Option<Response>>,
+}
+struct Process {
+    path: PathBuf,
+    child: Child,
+}
+impl Drop for Process {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+    }
+}
+impl Process {
+    fn run(process_path: &Path) -> Result<Process, io::Error> {
+        let child = Command::new(process_path.clone())
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .spawn()?;
+        Ok(Process { path: process_path.into(), child })
+    }
+    fn restart(&mut self) -> Result<(), io::Error> {
+        let _ = self.child.kill();
+        self.child = Command::new(self.path.clone())
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .spawn()?;
+        Ok(())
+    }
+    fn stdio(&mut self) -> Option<(impl Write, impl BufRead)> {
+        let stdin = self.child.stdin.take()?;
+        let stdout = self.child.stdout.take()?;
+        let read = BufReader::new(stdout);
+        Some((stdin, read))
+    }
+}
+impl ProcMacroProcessSrv {
+    pub fn run(
+        process_path: &Path,
+    ) -> Result<(ProcMacroProcessThread, ProcMacroProcessSrv), io::Error> {
+        let process = Process::run(process_path)?;
+        let (task_tx, task_rx) = bounded(0);
+        let handle = jod_thread::spawn(move || {
+            client_loop(task_rx, process);
+        });
+        let task_tx = Arc::new(task_tx);
+        let srv = ProcMacroProcessSrv { inner: Some(Arc::downgrade(&task_tx)) };
+        let thread = ProcMacroProcessThread { handle, sender: task_tx };
+        Ok((thread, srv))
+    }
+    pub fn find_proc_macros(
+        &self,
+        dylib_path: &Path,
+    ) -> Result<Vec<(String, ProcMacroKind)>, ra_tt::ExpansionError> {
+        let task = ListMacrosTask { lib: dylib_path.to_path_buf() };
+        let result: ListMacrosResult = self.send_task(Request::ListMacro(task))?;
+        Ok(result.macros)
+    }
+    pub fn custom_derive(
+        &self,
+        dylib_path: &Path,
+        subtree: &Subtree,
+        derive_name: &str,
+    ) -> Result<Subtree, ra_tt::ExpansionError> {
+        let task = ExpansionTask {
+            macro_body: subtree.clone(),
+            macro_name: derive_name.to_string(),
+            attributes: None,
+            lib: dylib_path.to_path_buf(),
+        };
+        let result: ExpansionResult = self.send_task(Request::ExpansionMacro(task))?;
+        Ok(result.expansion)
+    }
+    pub fn send_task<R>(&self, req: Request) -> Result<R, ra_tt::ExpansionError>
+    where
+        R: TryFrom<Response, Error = &'static str>,
+    {
+        let sender = match &self.inner {
+            None => return Err(ra_tt::ExpansionError::Unknown("No sender is found.".to_string())),
+            Some(it) => it,
+        };
+        let (result_tx, result_rx) = bounded(0);
+        let sender = match sender.upgrade() {
+            None => {
+                return Err(ra_tt::ExpansionError::Unknown("Proc macro process is closed.".into()))
+            }
+            Some(it) => it,
+        };
+        sender.send(Task { req: req.into(), result_tx }).unwrap();
+        let res = result_rx
+            .recv()
+            .map_err(|_| ra_tt::ExpansionError::Unknown("Proc macro thread is closed.".into()))?;
+        match res {
+            Some(Response::Error(err)) => {
+                return Err(ra_tt::ExpansionError::ExpansionError(err.message));
+            }
+            Some(res) => Ok(res.try_into().map_err(|err| {
+                ra_tt::ExpansionError::Unknown(format!(
+                    "Fail to get response, reason : {:#?} ",
+                    err
+                ))
+            })?),
+            None => Err(ra_tt::ExpansionError::Unknown("Empty result".into())),
+        }
+    }
+}
+fn client_loop(task_rx: Receiver<Task>, mut process: Process) {
+    let (mut stdin, mut stdout) = match process.stdio() {
+        None => return,
+        Some(it) => it,
+    };
+    for task in task_rx {
+        let Task { req, result_tx } = task;
+        match send_request(&mut stdin, &mut stdout, req) {
+            Ok(res) => result_tx.send(res).unwrap(),
+            Err(_err) => {
+                let res = Response::Error(ResponseError {
+                    code: ErrorCode::ServerErrorEnd,
+                    message: "Server closed".into(),
+                });
+                result_tx.send(res.into()).unwrap();
+                // Restart the process
+                if process.restart().is_err() {
+                    break;
+                }
+                let stdio = match process.stdio() {
+                    None => break,
+                    Some(it) => it,
+                };
+                stdin = stdio.0;
+                stdout = stdio.1;
+            }
+        }
+    }
+}
+fn send_request(
+    mut writer: &mut impl Write,
+    mut reader: &mut impl BufRead,
+    req: Request,
+) -> Result<Option<Response>, io::Error> {
+    req.write(&mut writer)?;
+    Ok(Response::read(&mut reader)?)
+}
diff --git a/crates/ra_proc_macro/src/rpc.rs b/crates/ra_proc_macro/src/rpc.rs
new file mode 100644
index 000000000..66b3f55db
--- /dev/null
+++ b/crates/ra_proc_macro/src/rpc.rs
@@ -0,0 +1,266 @@
+//! Data struture serialization related stuffs for RPC
+//!
+//! Define all necessary rpc serialization data structure,
+//! which include ra_tt related data and some task messages.
+//! Although adding Serialize and Deserialize trait to ra_tt directly seem to be much easier,
+//! we deliberately duplicate the ra_tt struct with #[serde(with = "XXDef")]
+//! for separation of code responsibility.
+use ra_tt::{
+    Delimiter, DelimiterKind, Ident, Leaf, Literal, Punct, SmolStr, Spacing, Subtree, TokenId,
+    TokenTree,
+};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize)]
+pub struct ListMacrosTask {
+    pub lib: PathBuf,
+}
+#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize)]
+pub enum ProcMacroKind {
+    CustomDerive,
+    FuncLike,
+    Attr,
+}
+#[derive(Clone, Eq, PartialEq, Debug, Default, Serialize, Deserialize)]
+pub struct ListMacrosResult {
+    pub macros: Vec<(String, ProcMacroKind)>,
+}
+#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize)]
+pub struct ExpansionTask {
+    /// Argument of macro call.
+    ///
+    /// In custom derive that would be a struct or enum; in attribute-like macro - underlying
+    /// item; in function-like macro - the macro body.
+    #[serde(with = "SubtreeDef")]
+    pub macro_body: Subtree,
+    /// Names of macros to expand.
+    ///
+    /// In custom derive those are names of derived traits (`Serialize`, `Getters`, etc.). In
+    /// attribute-like and functiona-like macros - single name of macro itself (`show_streams`).
+    pub macro_name: String,
+    /// Possible attributes for the attribute-like macros.
+    #[serde(with = "opt_subtree_def")]
+    pub attributes: Option<Subtree>,
+    pub lib: PathBuf,
+}
+#[derive(Clone, Eq, PartialEq, Debug, Default, Serialize, Deserialize)]
+pub struct ExpansionResult {
+    #[serde(with = "SubtreeDef")]
+    pub expansion: Subtree,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "DelimiterKind")]
+enum DelimiterKindDef {
+    Parenthesis,
+    Brace,
+    Bracket,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "TokenId")]
+struct TokenIdDef(u32);
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Delimiter")]
+struct DelimiterDef {
+    #[serde(with = "TokenIdDef")]
+    pub id: TokenId,
+    #[serde(with = "DelimiterKindDef")]
+    pub kind: DelimiterKind,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Subtree")]
+struct SubtreeDef {
+    #[serde(default, with = "opt_delimiter_def")]
+    pub delimiter: Option<Delimiter>,
+    #[serde(with = "vec_token_tree")]
+    pub token_trees: Vec<TokenTree>,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "TokenTree")]
+enum TokenTreeDef {
+    #[serde(with = "LeafDef")]
+    Leaf(Leaf),
+    #[serde(with = "SubtreeDef")]
+    Subtree(Subtree),
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Leaf")]
+enum LeafDef {
+    #[serde(with = "LiteralDef")]
+    Literal(Literal),
+    #[serde(with = "PunctDef")]
+    Punct(Punct),
+    #[serde(with = "IdentDef")]
+    Ident(Ident),
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Literal")]
+struct LiteralDef {
+    pub text: SmolStr,
+    #[serde(with = "TokenIdDef")]
+    pub id: TokenId,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Punct")]
+struct PunctDef {
+    pub char: char,
+    #[serde(with = "SpacingDef")]
+    pub spacing: Spacing,
+    #[serde(with = "TokenIdDef")]
+    pub id: TokenId,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Spacing")]
+enum SpacingDef {
+    Alone,
+    Joint,
+}
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Ident")]
+struct IdentDef {
+    pub text: SmolStr,
+    #[serde(with = "TokenIdDef")]
+    pub id: TokenId,
+}
+mod opt_delimiter_def {
+    use super::{Delimiter, DelimiterDef};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    pub fn serialize<S>(value: &Option<Delimiter>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        #[derive(Serialize)]
+        struct Helper<'a>(#[serde(with = "DelimiterDef")] &'a Delimiter);
+        value.as_ref().map(Helper).serialize(serializer)
+    }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Delimiter>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Helper(#[serde(with = "DelimiterDef")] Delimiter);
+        let helper = Option::deserialize(deserializer)?;
+        Ok(helper.map(|Helper(external)| external))
+    }
+}
+mod opt_subtree_def {
+    use super::{Subtree, SubtreeDef};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    pub fn serialize<S>(value: &Option<Subtree>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        #[derive(Serialize)]
+        struct Helper<'a>(#[serde(with = "SubtreeDef")] &'a Subtree);
+        value.as_ref().map(Helper).serialize(serializer)
+    }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Subtree>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Helper(#[serde(with = "SubtreeDef")] Subtree);
+        let helper = Option::deserialize(deserializer)?;
+        Ok(helper.map(|Helper(external)| external))
+    }
+}
+mod vec_token_tree {
+    use super::{TokenTree, TokenTreeDef};
+    use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
+    pub fn serialize<S>(value: &Vec<TokenTree>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        #[derive(Serialize)]
+        struct Helper<'a>(#[serde(with = "TokenTreeDef")] &'a TokenTree);
+        let items: Vec<_> = value.iter().map(Helper).collect();
+        let mut seq = serializer.serialize_seq(Some(items.len()))?;
+        for element in items {
+            seq.serialize_element(&element)?;
+        }
+        seq.end()
+    }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<TokenTree>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Helper(#[serde(with = "TokenTreeDef")] TokenTree);
+        let helper = Vec::deserialize(deserializer)?;
+        Ok(helper.into_iter().map(|Helper(external)| external).collect())
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn fixture_token_tree() -> Subtree {
+        let mut subtree = Subtree::default();
+        subtree
+            .token_trees
+            .push(TokenTree::Leaf(Ident { text: "struct".into(), id: TokenId(0) }.into()));
+        subtree
+            .token_trees
+            .push(TokenTree::Leaf(Ident { text: "Foo".into(), id: TokenId(1) }.into()));
+        subtree.token_trees.push(TokenTree::Subtree(
+            Subtree {
+                delimiter: Some(Delimiter { id: TokenId(2), kind: DelimiterKind::Brace }),
+                token_trees: vec![],
+            }
+            .into(),
+        ));
+        subtree
+    }
+    #[test]
+    fn test_proc_macro_rpc_works() {
+        let tt = fixture_token_tree();
+        let task = ExpansionTask {
+            macro_body: tt.clone(),
+            macro_name: Default::default(),
+            attributes: None,
+            lib: Default::default(),
+        };
+        let json = serde_json::to_string(&task).unwrap();
+        let back: ExpansionTask = serde_json::from_str(&json).unwrap();
+        assert_eq!(task.macro_body, back.macro_body);
+        let result = ExpansionResult { expansion: tt.clone() };
+        let json = serde_json::to_string(&result).unwrap();
+        let back: ExpansionResult = serde_json::from_str(&json).unwrap();
+        assert_eq!(result, back);
+    }
+}
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 9e167db96..00ea3a9b0 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -339,6 +339,14 @@ pub fn print_backtrace() {
    let bt = backtrace::Backtrace::new();
    eprintln!("{:?}", bt);
 }
+#[cfg(not(feature = "backtrace"))]
+pub fn print_backtrace() {
+    eprintln!(
+        r#"enable the backtrace feature:
+    ra_prof = {{ path = "../ra_prof", features = [ "backtrace"] }}
+"#
+    );
+}
 thread_local!(static IN_SCOPE: RefCell<bool> = RefCell::new(false));
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index cdcdd63c9..b10644b4b 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -16,7 +16,6 @@ cargo_metadata = "0.9.1"
 ra_arena = { path = "../ra_arena" }
 ra_db = { path = "../ra_db" }
 ra_cfg = { path = "../ra_cfg" }
-ra_cargo_watch = { path = "../ra_cargo_watch" }
 ra_proc_macro =  { path = "../ra_proc_macro" }
 serde = { version = "1.0.104", features = ["derive"] }
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 291594e2a..f4fd6ad28 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -1,14 +1,16 @@
 //! FIXME: write short doc here
 use std::{
+    env,
+    ffi::OsStr,
    ops,
    path::{Path, PathBuf},
+    process::Command,
 };
 use anyhow::{Context, Result};
 use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
 use ra_arena::{Arena, Idx};
-use ra_cargo_watch::run_cargo;
 use ra_db::Edition;
 use rustc_hash::FxHashMap;
 use serde::Deserialize;
@@ -75,6 +77,7 @@ pub type Target = Idx<TargetData>;
 #[derive(Debug, Clone)]
 pub struct PackageData {
+    pub id: String,
    pub name: String,
    pub manifest: PathBuf,
    pub targets: Vec<Target>,
@@ -161,7 +164,7 @@ impl CargoWorkspace {
        let mut out_dir_by_id = FxHashMap::default();
        let mut proc_macro_dylib_paths = FxHashMap::default();
        if cargo_features.load_out_dirs_from_check {
-            let resources = load_extern_resources(cargo_toml, cargo_features);
+            let resources = load_extern_resources(cargo_toml, cargo_features)?;
            out_dir_by_id = resources.out_dirs;
            proc_macro_dylib_paths = resources.proc_dylib_paths;
        }
@@ -180,6 +183,7 @@ impl CargoWorkspace {
                .with_context(|| format!("Failed to parse edition {}", edition))?;
            let pkg = packages.alloc(PackageData {
                name,
+                id: id.to_string(),
                manifest: manifest_path,
                targets: Vec::new(),
                is_member,
@@ -249,6 +253,18 @@ impl CargoWorkspace {
    pub fn workspace_root(&self) -> &Path {
        &self.workspace_root
    }
+    pub fn package_flag(&self, package: &PackageData) -> String {
+        if self.is_unique(&*package.name) {
+            package.name.clone()
+        } else {
+            package.id.clone()
+        }
+    }
+    fn is_unique(&self, name: &str) -> bool {
+        self.packages.iter().filter(|(_, v)| v.name == name).count() == 1
+    }
 }
 #[derive(Debug, Clone, Default)]
@@ -257,48 +273,61 @@ pub struct ExternResources {
    proc_dylib_paths: FxHashMap<PackageId, PathBuf>,
 }
-pub fn load_extern_resources(cargo_toml: &Path, cargo_features: &CargoFeatures) -> ExternResources {
+pub fn load_extern_resources(
-    let mut args: Vec<String> = vec![
+    cargo_toml: &Path,
-        "check".to_string(),
+    cargo_features: &CargoFeatures,
-        "--message-format=json".to_string(),
+) -> Result<ExternResources> {
-        "--manifest-path".to_string(),
+    let mut cmd = Command::new(cargo_binary());
-        cargo_toml.display().to_string(),
+    cmd.args(&["check", "--message-format=json", "--manifest-path"]).arg(cargo_toml);
-    ];
    if cargo_features.all_features {
-        args.push("--all-features".to_string());
+        cmd.arg("--all-features");
    } else if cargo_features.no_default_features {
        // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
        // https://github.com/oli-obk/cargo_metadata/issues/79
-        args.push("--no-default-features".to_string());
+        cmd.arg("--no-default-features");
    } else {
-        args.extend(cargo_features.features.iter().cloned());
+        cmd.args(&cargo_features.features);
    }
-    let mut acc = ExternResources::default();
+    let output = cmd.output()?;
-    let res = run_cargo(&args, cargo_toml.parent(), &mut |message| {
-        match message {
-            Message::BuildScriptExecuted(BuildScript { package_id, out_dir, .. }) => {
-                acc.out_dirs.insert(package_id, out_dir);
-            }
-            Message::CompilerArtifact(message) => {
+    let mut res = ExternResources::default();
-                if message.target.kind.contains(&"proc-macro".to_string()) {
-                    let package_id = message.package_id;
+    let stdout = String::from_utf8(output.stdout)?;
-                    if let Some(filename) = message.filenames.get(0) {
+    for line in stdout.lines() {
-                        acc.proc_dylib_paths.insert(package_id, filename.clone());
+        if let Ok(message) = serde_json::from_str::<cargo_metadata::Message>(&line) {
+            match message {
+                Message::BuildScriptExecuted(BuildScript { package_id, out_dir, .. }) => {
+                    res.out_dirs.insert(package_id, out_dir);
+                }
+                Message::CompilerArtifact(message) => {
+                    if message.target.kind.contains(&"proc-macro".to_string()) {
+                        let package_id = message.package_id;
+                        // Skip rmeta file
+                        if let Some(filename) =
+                            message.filenames.iter().filter(|name| is_dylib(name)).next()
+                        {
+                            res.proc_dylib_paths.insert(package_id, filename.clone());
+                        }
                    }
                }
+                Message::CompilerMessage(_) => (),
+                Message::Unknown => (),
            }
-            Message::CompilerMessage(_) => (),
-            Message::Unknown => (),
        }
-        true
+    }
-    });
+    Ok(res)
+}
-    if let Err(err) = res {
+// FIXME: File a better way to know if it is a dylib
-        log::error!("Failed to load outdirs: {:?}", err);
+fn is_dylib(path: &Path) -> bool {
+    match path.extension().and_then(OsStr::to_str).map(|it| it.to_string().to_lowercase()) {
+        None => false,
+        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
    }
+}
-    acc
+fn cargo_binary() -> String {
+    env::var("CARGO").unwrap_or_else(|_| "cargo".to_string())
 }
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 2304e00cf..b69cae234 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -46,14 +46,46 @@ impl ast::FnDef {
    }
 }
+fn make_multiline<N>(node: N) -> N
+where
+    N: AstNode + Clone,
+{
+    let l_curly = match node.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
+        Some(it) => it,
+        None => return node,
+    };
+    let sibling = match l_curly.next_sibling_or_token() {
+        Some(it) => it,
+        None => return node,
+    };
+    let existing_ws = match sibling.as_token() {
+        None => None,
+        Some(tok) if tok.kind() != WHITESPACE => None,
+        Some(ws) => {
+            if ws.text().contains('\n') {
+                return node;
+            }
+            Some(ws.clone())
+        }
+    };
+    let indent = leading_indent(node.syntax()).unwrap_or_default();
+    let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
+    let to_insert = iter::once(ws.ws().into());
+    match existing_ws {
+        None => node.insert_children(InsertPosition::After(l_curly), to_insert),
+        Some(ws) => node.replace_children(single_node(ws), to_insert),
+    }
+}
 impl ast::ItemList {
    #[must_use]
-    pub fn append_items(&self, items: impl Iterator<Item = ast::ImplItem>) -> ast::ItemList {
+    pub fn append_items(&self, items: impl IntoIterator<Item = ast::ImplItem>) -> ast::ItemList {
        let mut res = self.clone();
        if !self.syntax().text().contains_char('\n') {
-            res = res.make_multiline();
+            res = make_multiline(res);
        }
-        items.for_each(|it| res = res.append_item(it));
+        items.into_iter().for_each(|it| res = res.append_item(it));
        res
    }
@@ -81,35 +113,6 @@ impl ast::ItemList {
    fn l_curly(&self) -> Option<SyntaxElement> {
        self.syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
    }
-    fn make_multiline(&self) -> ast::ItemList {
-        let l_curly = match self.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
-            Some(it) => it,
-            None => return self.clone(),
-        };
-        let sibling = match l_curly.next_sibling_or_token() {
-            Some(it) => it,
-            None => return self.clone(),
-        };
-        let existing_ws = match sibling.as_token() {
-            None => None,
-            Some(tok) if tok.kind() != WHITESPACE => None,
-            Some(ws) => {
-                if ws.text().contains('\n') {
-                    return self.clone();
-                }
-                Some(ws.clone())
-            }
-        };
-        let indent = leading_indent(self.syntax()).unwrap_or_default();
-        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
-        let to_insert = iter::once(ws.ws().into());
-        match existing_ws {
-            None => self.insert_children(InsertPosition::After(l_curly), to_insert),
-            Some(ws) => self.replace_children(single_node(ws), to_insert),
-        }
-    }
 }
 impl ast::RecordFieldList {
@@ -334,6 +337,80 @@ impl ast::UseTree {
    }
 }
+impl ast::MatchArmList {
+    #[must_use]
+    pub fn append_arms(&self, items: impl IntoIterator<Item = ast::MatchArm>) -> ast::MatchArmList {
+        let mut res = self.clone();
+        res = res.strip_if_only_whitespace();
+        if !res.syntax().text().contains_char('\n') {
+            res = make_multiline(res);
+        }
+        items.into_iter().for_each(|it| res = res.append_arm(it));
+        res
+    }
+    fn strip_if_only_whitespace(&self) -> ast::MatchArmList {
+        let mut iter = self.syntax().children_with_tokens().skip_while(|it| it.kind() != T!['{']);
+        iter.next(); // Eat the curly
+        let mut inner = iter.take_while(|it| it.kind() != T!['}']);
+        if !inner.clone().all(|it| it.kind() == WHITESPACE) {
+            return self.clone();
+        }
+        let start = match inner.next() {
+            Some(s) => s,
+            None => return self.clone(),
+        };
+        let end = match inner.last() {
+            Some(s) => s,
+            None => start.clone(),
+        };
+        self.replace_children(start..=end, &mut iter::empty())
+    }
+    #[must_use]
+    pub fn remove_placeholder(&self) -> ast::MatchArmList {
+        let placeholder =
+            self.arms().find(|arm| matches!(arm.pat(), Some(ast::Pat::PlaceholderPat(_))));
+        if let Some(placeholder) = placeholder {
+            self.remove_arm(&placeholder)
+        } else {
+            self.clone()
+        }
+    }
+    #[must_use]
+    fn remove_arm(&self, arm: &ast::MatchArm) -> ast::MatchArmList {
+        let start = arm.syntax().clone();
+        let end = if let Some(comma) = start
+            .siblings_with_tokens(Direction::Next)
+            .skip(1)
+            .skip_while(|it| it.kind().is_trivia())
+            .next()
+            .filter(|it| it.kind() == T![,])
+        {
+            comma
+        } else {
+            start.clone().into()
+        };
+        self.replace_children(start.into()..=end, None)
+    }
+    #[must_use]
+    pub fn append_arm(&self, item: ast::MatchArm) -> ast::MatchArmList {
+        let r_curly = match self.syntax().children_with_tokens().find(|it| it.kind() == T!['}']) {
+            Some(t) => t,
+            None => return self.clone(),
+        };
+        let position = InsertPosition::Before(r_curly.into());
+        let arm_ws = tokens::WsBuilder::new("    ");
+        let match_indent = &leading_indent(self.syntax()).unwrap_or_default();
+        let match_ws = tokens::WsBuilder::new(&format!("\n{}", match_indent));
+        let to_insert: ArrayVec<[SyntaxElement; 3]> =
+            [arm_ws.ws().into(), item.syntax().clone().into(), match_ws.ws().into()].into();
+        self.insert_children(position, to_insert)
+    }
+}
 #[must_use]
 pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
    N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
diff --git a/crates/ra_syntax/src/parsing/text_tree_sink.rs b/crates/ra_syntax/src/parsing/text_tree_sink.rs
index dd202601d..87bb21cd9 100644
--- a/crates/ra_syntax/src/parsing/text_tree_sink.rs
+++ b/crates/ra_syntax/src/parsing/text_tree_sink.rs
@@ -149,10 +149,21 @@ fn n_attached_trivias<'a>(
        MACRO_CALL | CONST_DEF | TYPE_ALIAS_DEF | STRUCT_DEF | ENUM_DEF | ENUM_VARIANT | FN_DEF
        | TRAIT_DEF | MODULE | RECORD_FIELD_DEF | STATIC_DEF => {
            let mut res = 0;
-            for (i, (kind, text)) in trivias.enumerate() {
+            let mut trivias = trivias.enumerate().peekable();
+            while let Some((i, (kind, text))) = trivias.next() {
                match kind {
                    WHITESPACE => {
                        if text.contains("\n\n") {
+                            // we check whether the next token is a doc-comment
+                            // and skip the whitespace in this case
+                            if let Some((peek_kind, peek_text)) =
+                                trivias.peek().map(|(_, pair)| pair)
+                            {
+                                if *peek_kind == COMMENT && peek_text.starts_with("///") {
+                                    continue;
+                                }
+                            }
                            break;
                        }
                    }
diff --git a/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.rs b/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.rs
new file mode 100644
index 000000000..1fafe216b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.rs
@@ -0,0 +1,3 @@
+/// Example
+fn test() {}
diff --git a/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.txt b/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.txt
new file mode 100644
index 000000000..91d0c3736
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0065_comment_newline.txt
@@ -0,0 +1,17 @@
+SOURCE_FILE@[0; 26)
+  FN_DEF@[0; 25)
+    COMMENT@[0; 11) "/// Example"
+    WHITESPACE@[11; 13) "\n\n"
+    FN_KW@[13; 15) "fn"
+    WHITESPACE@[15; 16) " "
+    NAME@[16; 20)
+      IDENT@[16; 20) "test"
+    PARAM_LIST@[20; 22)
+      L_PAREN@[20; 21) "("
+      R_PAREN@[21; 22) ")"
+    WHITESPACE@[22; 23) " "
+    BLOCK_EXPR@[23; 25)
+      BLOCK@[23; 25)
+        L_CURLY@[23; 24) "{"
+        R_CURLY@[24; 25) "}"
+  WHITESPACE@[25; 26) "\n"
diff --git a/crates/ra_tt/src/lib.rs b/crates/ra_tt/src/lib.rs
index 1015ce0a6..bd484aa30 100644
--- a/crates/ra_tt/src/lib.rs
+++ b/crates/ra_tt/src/lib.rs
@@ -189,7 +189,12 @@ impl Subtree {
 pub mod buffer;
 #[derive(Debug, PartialEq, Eq)]
-pub enum ExpansionError {}
+pub enum ExpansionError {
+    IOError(String),
+    JsonError(String),
+    Unknown(String),
+    ExpansionError(String),
+}
 pub trait TokenExpander: Debug + Send + Sync + RefUnwindSafe {
    fn expand(&self, subtree: &Subtree, attrs: Option<&Subtree>)
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 8fe6799d2..f5f773432 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -33,7 +33,7 @@ threadpool = "1.7.1"
 stdx = { path = "../stdx" }
 lsp-server = "0.3.1"
-ra_cargo_watch = { path = "../ra_cargo_watch" }
+ra_flycheck = { path = "../ra_flycheck" }
 ra_ide = { path = "../ra_ide" }
 ra_prof = { path = "../ra_prof" }
 ra_project_model = { path = "../ra_project_model" }
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
index f87bdcec5..942c30328 100644
--- a/crates/rust-analyzer/src/cargo_target_spec.rs
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -77,7 +77,7 @@ impl CargoTargetSpec {
            ProjectWorkspace::Cargo { cargo, .. } => {
                let tgt = cargo.target_by_root(&path)?;
                Some(CargoTargetSpec {
-                    package: cargo[cargo[tgt].package].name.clone(),
+                    package: cargo.package_flag(&cargo[cargo[tgt].package]),
                    target: cargo[tgt].name.clone(),
                    target_kind: cargo[tgt].kind,
                })
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 7164b0ade..7667873d5 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -12,7 +12,7 @@ use ra_db::{
    salsa::{Database, Durability},
    FileId, SourceDatabaseExt,
 };
-use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CompletionOptions, FilePosition, LineCol};
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CompletionConfig, FilePosition, LineCol};
 use crate::cli::{load_cargo::load_cargo, Verbosity};
@@ -102,7 +102,7 @@ pub fn analysis_bench(
            let file_position = FilePosition { file_id, offset };
            if is_completion {
-                let options = CompletionOptions::default();
+                let options = CompletionConfig::default();
                let res = do_work(&mut host, file_id, |analysis| {
                    analysis.completions(file_position, &options)
                });
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index 6edc03fe0..e8dc953c3 100644
--- a/crates/rust-analyzer/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -579,7 +579,7 @@ impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<Vec<NavigationTarget>>)
            .into_iter()
            .map(|nav| (file_id, RangeInfo::new(range, nav)))
            .try_conv_with_to_vec(world)?;
-        if world.options.supports_location_link {
+        if world.config.supports_location_link {
            Ok(links.into())
        } else {
            let locations: Vec<Location> = links
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 7825b0077..79dc03de4 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -14,14 +14,15 @@ use std::{
    time::{Duration, Instant},
 };
-use crossbeam_channel::{select, unbounded, RecvError, Sender};
+use crossbeam_channel::{never, select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{
-    ClientCapabilities, NumberOrString, WorkDoneProgress, WorkDoneProgressBegin,
+    ClientCapabilities, NumberOrString, TextDocumentClientCapabilities, WorkDoneProgress,
-    WorkDoneProgressCreateParams, WorkDoneProgressEnd, WorkDoneProgressReport,
+    WorkDoneProgressBegin, WorkDoneProgressCreateParams, WorkDoneProgressEnd,
+    WorkDoneProgressReport,
 };
-use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckTask};
+use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckConfig, CheckTask};
-use ra_ide::{Canceled, FileId, InlayHintsOptions, LibraryData, SourceRootId};
+use ra_ide::{Canceled, FileId, InlayHintsConfig, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
@@ -37,9 +38,10 @@ use crate::{
        subscriptions::Subscriptions,
    },
    req,
-    world::{Options, WorldSnapshot, WorldState},
+    world::{Config, WorldSnapshot, WorldState},
    Result, ServerConfig,
 };
+use req::ConfigurationParams;
 #[derive(Debug)]
 pub struct LspError {
@@ -63,6 +65,57 @@ impl fmt::Display for LspError {
 impl Error for LspError {}
+fn get_feature_flags(config: &ServerConfig, connection: &Connection) -> FeatureFlags {
+    let mut ff = FeatureFlags::default();
+    for (flag, &value) in &config.feature_flags {
+        if ff.set(flag.as_str(), value).is_err() {
+            log::error!("unknown feature flag: {:?}", flag);
+            show_message(
+                req::MessageType::Error,
+                format!("unknown feature flag: {:?}", flag),
+                &connection.sender,
+            );
+        }
+    }
+    log::info!("feature_flags: {:#?}", ff);
+    ff
+}
+fn get_config(
+    config: &ServerConfig,
+    text_document_caps: Option<&TextDocumentClientCapabilities>,
+) -> Config {
+    Config {
+        publish_decorations: config.publish_decorations,
+        supports_location_link: text_document_caps
+            .and_then(|it| it.definition)
+            .and_then(|it| it.link_support)
+            .unwrap_or(false),
+        line_folding_only: text_document_caps
+            .and_then(|it| it.folding_range.as_ref())
+            .and_then(|it| it.line_folding_only)
+            .unwrap_or(false),
+        inlay_hints: InlayHintsConfig {
+            type_hints: config.inlay_hints_type,
+            parameter_hints: config.inlay_hints_parameter,
+            chaining_hints: config.inlay_hints_chaining,
+            max_length: config.inlay_hints_max_length,
+        },
+        check: if config.cargo_watch_enable {
+            Some(CheckConfig {
+                args: config.cargo_watch_args.clone(),
+                command: config.cargo_watch_command.clone(),
+                all_targets: config.cargo_watch_all_targets,
+            })
+        } else {
+            None
+        },
+        rustfmt_args: config.rustfmt_args.clone(),
+        vscode_lldb: config.vscode_lldb,
+        proc_macro_srv: None, // FIXME: get this from config
+    }
+}
 pub fn main_loop(
    ws_roots: Vec<PathBuf>,
    client_caps: ClientCapabilities,
@@ -90,23 +143,10 @@ pub fn main_loop(
        SetThreadPriority(thread, thread_priority_above_normal);
    }
+    let text_document_caps = client_caps.text_document.as_ref();
    let mut loop_state = LoopState::default();
    let mut world_state = {
-        let feature_flags = {
+        let feature_flags = get_feature_flags(&config, &connection);
-            let mut ff = FeatureFlags::default();
-            for (flag, value) in config.feature_flags {
-                if ff.set(flag.as_str(), value).is_err() {
-                    log::error!("unknown feature flag: {:?}", flag);
-                    show_message(
-                        req::MessageType::Error,
-                        format!("unknown feature flag: {:?}", flag),
-                        &connection.sender,
-                    );
-                }
-            }
-            ff
-        };
-        log::info!("feature_flags: {:#?}", feature_flags);
        // FIXME: support dynamic workspace loading.
        let workspaces = {
@@ -168,46 +208,20 @@ pub fn main_loop(
            connection.sender.send(request.into()).unwrap();
        }
-        let options = {
-            let text_document_caps = client_caps.text_document.as_ref();
-            Options {
-                publish_decorations: config.publish_decorations,
-                supports_location_link: text_document_caps
-                    .and_then(|it| it.definition)
-                    .and_then(|it| it.link_support)
-                    .unwrap_or(false),
-                line_folding_only: text_document_caps
-                    .and_then(|it| it.folding_range.as_ref())
-                    .and_then(|it| it.line_folding_only)
-                    .unwrap_or(false),
-                inlay_hints: InlayHintsOptions {
-                    type_hints: config.inlay_hints_type,
-                    parameter_hints: config.inlay_hints_parameter,
-                    chaining_hints: config.inlay_hints_chaining,
-                    max_length: config.inlay_hints_max_length,
-                },
-                cargo_watch: CheckOptions {
-                    enable: config.cargo_watch_enable,
-                    args: config.cargo_watch_args,
-                    command: config.cargo_watch_command,
-                    all_targets: config.cargo_watch_all_targets,
-                },
-                rustfmt_args: config.rustfmt_args,
-                vscode_lldb: config.vscode_lldb,
-            }
-        };
        WorldState::new(
            ws_roots,
            workspaces,
            config.lru_capacity,
            &globs,
            Watch(!config.use_client_watching),
-            options,
+            get_config(&config, text_document_caps),
            feature_flags,
        )
    };
+    loop_state.roots_total = world_state.vfs.read().n_roots();
+    loop_state.roots_scanned = 0;
    let pool = ThreadPool::default();
    let (task_sender, task_receiver) = unbounded::<Task>();
    let (libdata_sender, libdata_receiver) = unbounded::<LibraryData>();
@@ -229,7 +243,7 @@ pub fn main_loop(
                    Err(RecvError) => return Err("vfs died".into()),
                },
                recv(libdata_receiver) -> data => Event::Lib(data.unwrap()),
-                recv(world_state.check_watcher.task_recv) -> task => match task {
+                recv(world_state.flycheck.as_ref().map_or(&never(), |it| &it.task_recv)) -> task => match task {
                    Ok(task) => Event::CheckWatcher(task),
                    Err(RecvError) => return Err("check watcher died".into()),
                }
@@ -244,6 +258,7 @@ pub fn main_loop(
                &task_sender,
                &libdata_sender,
                &connection,
+                text_document_caps,
                &mut world_state,
                &mut loop_state,
                event,
@@ -333,7 +348,10 @@ struct LoopState {
    in_flight_libraries: usize,
    pending_libraries: Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>,
    workspace_loaded: bool,
-    roots_scanned_progress: Option<usize>,
+    roots_progress_reported: Option<usize>,
+    roots_scanned: usize,
+    roots_total: usize,
+    configuration_request_id: Option<RequestId>,
 }
 impl LoopState {
@@ -351,6 +369,7 @@ fn loop_turn(
    task_sender: &Sender<Task>,
    libdata_sender: &Sender<LibraryData>,
    connection: &Connection,
+    text_document_caps: Option<&TextDocumentClientCapabilities>,
    world_state: &mut WorldState,
    loop_state: &mut LoopState,
    event: Event,
@@ -377,6 +396,7 @@ fn loop_turn(
            world_state.add_lib(lib);
            world_state.maybe_collect_garbage();
            loop_state.in_flight_libraries -= 1;
+            loop_state.roots_scanned += 1;
        }
        Event::CheckWatcher(task) => on_check_task(task, world_state, task_sender)?,
        Event::Msg(msg) => match msg {
@@ -390,25 +410,53 @@ fn loop_turn(
                req,
            )?,
            Message::Notification(not) => {
-                on_notification(
+                on_notification(&connection.sender, world_state, loop_state, not)?;
-                    &connection.sender,
-                    world_state,
-                    &mut loop_state.pending_requests,
-                    &mut loop_state.subscriptions,
-                    not,
-                )?;
            }
            Message::Response(resp) => {
                let removed = loop_state.pending_responses.remove(&resp.id);
                if !removed {
                    log::error!("unexpected response: {:?}", resp)
                }
+                if Some(&resp.id) == loop_state.configuration_request_id.as_ref() {
+                    loop_state.configuration_request_id = None;
+                    log::debug!("config update response: '{:?}", resp);
+                    let Response { error, result, .. } = resp;
+                    match (
+                        error,
+                        result.map(|result| serde_json::from_value::<Vec<ServerConfig>>(result)),
+                    ) {
+                        (Some(err), _) => {
+                            log::error!("failed to fetch the server settings: {:?}", err)
+                        }
+                        (None, Some(Ok(new_config))) => {
+                            let new_config = new_config
+                                .first()
+                                .expect(
+                                    "the client is expected to always send a non-empty config data",
+                                )
+                                .to_owned();
+                            world_state.update_configuration(
+                                new_config.lru_capacity,
+                                get_config(&new_config, text_document_caps),
+                                get_feature_flags(&new_config, connection),
+                            );
+                        }
+                        (None, Some(Err(e))) => {
+                            log::error!("failed to parse client config response: {}", e)
+                        }
+                        (None, None) => {
+                            log::error!("received empty server settings response from the client")
+                        }
+                    }
+                }
            }
        },
    };
    let mut state_changed = false;
-    if let Some(changes) = world_state.process_changes() {
+    if let Some(changes) = world_state.process_changes(&mut loop_state.roots_scanned) {
        state_changed = true;
        loop_state.pending_libraries.extend(changes);
    }
@@ -427,28 +475,34 @@ fn loop_turn(
        });
    }
+    let show_progress = !loop_state.workspace_loaded
+        && world_state.feature_flags.get("notifications.workspace-loaded");
    if !loop_state.workspace_loaded
-        && world_state.roots_to_scan == 0
+        && loop_state.roots_scanned == loop_state.roots_total
        && loop_state.pending_libraries.is_empty()
        && loop_state.in_flight_libraries == 0
    {
        loop_state.workspace_loaded = true;
-        world_state.check_watcher.update();
+        if let Some(flycheck) = &world_state.flycheck {
+            flycheck.update();
+        }
        pool.execute({
            let subs = loop_state.subscriptions.subscriptions();
            let snap = world_state.snapshot();
            move || snap.analysis().prime_caches(subs).unwrap_or_else(|_: Canceled| ())
        });
-        send_startup_progress(&connection.sender, loop_state, world_state);
+    }
-    } else if !loop_state.workspace_loaded {
-        send_startup_progress(&connection.sender, loop_state, world_state);
+    if show_progress {
+        send_startup_progress(&connection.sender, loop_state);
    }
    if state_changed {
        update_file_notifications_on_threadpool(
            pool,
            world_state.snapshot(),
-            world_state.options.publish_decorations,
+            world_state.config.publish_decorations,
            task_sender.clone(),
            loop_state.subscriptions.subscriptions(),
        )
@@ -556,8 +610,7 @@ fn on_request(
 fn on_notification(
    msg_sender: &Sender<Message>,
    state: &mut WorldState,
-    pending_requests: &mut PendingRequests,
+    loop_state: &mut LoopState,
-    subs: &mut Subscriptions,
    not: Notification,
 ) -> Result<()> {
    let not = match notification_cast::<req::Cancel>(not) {
@@ -566,7 +619,7 @@ fn on_notification(
                NumberOrString::Number(id) => id.into(),
                NumberOrString::String(id) => id.into(),
            };
-            if pending_requests.cancel(&id) {
+            if loop_state.pending_requests.cancel(&id) {
                let response = Response::new_err(
                    id,
                    ErrorCode::RequestCanceled as i32,
@@ -585,7 +638,7 @@ fn on_notification(
            if let Some(file_id) =
                state.vfs.write().add_file_overlay(&path, params.text_document.text)
            {
-                subs.add_sub(FileId(file_id.0));
+                loop_state.subscriptions.add_sub(FileId(file_id.0));
            }
            return Ok(());
        }
@@ -604,7 +657,9 @@ fn on_notification(
    };
    let not = match notification_cast::<req::DidSaveTextDocument>(not) {
        Ok(_params) => {
-            state.check_watcher.update();
+            if let Some(flycheck) = &state.flycheck {
+                flycheck.update();
+            }
            return Ok(());
        }
        Err(not) => not,
@@ -614,7 +669,7 @@ fn on_notification(
            let uri = params.text_document.uri;
            let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
            if let Some(file_id) = state.vfs.write().remove_file_overlay(path.as_path()) {
-                subs.remove_sub(FileId(file_id.0));
+                loop_state.subscriptions.remove_sub(FileId(file_id.0));
            }
            let params =
                req::PublishDiagnosticsParams { uri, diagnostics: Vec::new(), version: None };
@@ -625,7 +680,17 @@ fn on_notification(
        Err(not) => not,
    };
    let not = match notification_cast::<req::DidChangeConfiguration>(not) {
-        Ok(_params) => {
+        Ok(_) => {
+            // As stated in https://github.com/microsoft/language-server-protocol/issues/676,
+            // this notification's parameters should be ignored and the actual config queried separately.
+            let request_id = loop_state.next_request_id();
+            let request = request_new::<req::WorkspaceConfiguration>(
+                request_id.clone(),
+                ConfigurationParams::default(),
+            );
+            msg_sender.send(request.into())?;
+            loop_state.configuration_request_id = Some(request_id);
            return Ok(());
        }
        Err(not) => not,
@@ -706,21 +771,13 @@ fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state:
    }
 }
-fn send_startup_progress(
+fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) {
-    sender: &Sender<Message>,
+    let total: usize = loop_state.roots_total;
-    loop_state: &mut LoopState,
+    let prev = loop_state.roots_progress_reported;
-    world_state: &WorldState,
+    let progress = loop_state.roots_scanned;
-) {
+    loop_state.roots_progress_reported = Some(progress);
-    if !world_state.feature_flags.get("notifications.workspace-loaded") {
-        return;
-    }
-    let total: usize = world_state.workspaces.iter().map(|it| it.n_packages()).sum();
+    match (prev, loop_state.workspace_loaded) {
-    let prev_progress = loop_state.roots_scanned_progress;
-    let progress = total - world_state.roots_to_scan;
-    loop_state.roots_scanned_progress = Some(progress);
-    match (prev_progress, loop_state.workspace_loaded) {
        (None, false) => {
            let work_done_progress_create = request_new::<req::WorkDoneProgressCreate>(
                loop_state.next_request_id(),
@@ -755,14 +812,14 @@ fn send_startup_progress(
        ),
        _ => {}
    }
-}
-fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) {
+    fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) {
-    let notif = notification_new::<req::Progress>(req::ProgressParams {
+        let notif = notification_new::<req::Progress>(req::ProgressParams {
-        token: req::ProgressToken::String("rustAnalyzer/startup".into()),
+            token: req::ProgressToken::String("rustAnalyzer/startup".into()),
-        value: req::ProgressParamsValue::WorkDone(work_done_progress),
+            value: req::ProgressParamsValue::WorkDone(work_done_progress),
-    });
+        });
-    sender.send(notif.into()).unwrap();
+        sender.send(notif.into()).unwrap();
+    }
 }
 struct PoolDispatcher<'a> {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 12f8ca297..d5cb5d137 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -14,12 +14,12 @@ use lsp_types::{
    CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams,
    Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
-    Range, RenameParams, SemanticTokens, SemanticTokensParams, SemanticTokensRangeParams,
+    Range, RenameParams, SemanticTokensParams, SemanticTokensRangeParams,
    SemanticTokensRangeResult, SemanticTokensResult, SymbolInformation, TextDocumentIdentifier,
    TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
-    Assist, AssistId, CompletionOptions, FileId, FilePosition, FileRange, Query, RangeInfo,
+    Assist, AssistId, CompletionConfig, FileId, FilePosition, FileRange, Query, RangeInfo,
    Runnable, RunnableKind, SearchScope,
 };
 use ra_prof::profile;
@@ -425,7 +425,7 @@ pub fn handle_completion(
        return Ok(None);
    }
-    let options = CompletionOptions {
+    let config = CompletionConfig {
        enable_postfix_completions: world.feature_flags.get("completion.enable-postfix"),
        add_call_parenthesis: world.feature_flags.get("completion.insertion.add-call-parenthesis"),
        add_call_argument_snippets: world
@@ -433,7 +433,7 @@ pub fn handle_completion(
            .get("completion.insertion.add-argument-snippets"),
    };
-    let items = match world.analysis().completions(position, &options)? {
+    let items = match world.analysis().completions(position, &config)? {
        None => return Ok(None),
        Some(items) => items,
    };
@@ -457,7 +457,7 @@ pub fn handle_folding_range(
    let ctx = FoldConvCtx {
        text: &text,
        line_index: &line_index,
-        line_folding_only: world.options.line_folding_only,
+        line_folding_only: world.config.line_folding_only,
    };
    let res = Some(folds.into_iter().map_conv_with(&ctx).collect());
    Ok(res)
@@ -611,7 +611,7 @@ pub fn handle_formatting(
    let end_position = TextUnit::of_str(&file).conv_with(&file_line_index);
    let mut rustfmt = process::Command::new("rustfmt");
-    rustfmt.args(&world.options.rustfmt_args);
+    rustfmt.args(&world.config.rustfmt_args);
    if let Some(&crate_id) = crate_ids.first() {
        // Assume all crates are in the same edition
        let edition = world.analysis().crate_edition(crate_id)?;
@@ -815,7 +815,7 @@ pub fn handle_code_lens(
        };
        lenses.push(lens);
-        if world.options.vscode_lldb {
+        if world.config.vscode_lldb {
            if r.args[0] == "run" {
                r.args[0] = "build".into();
            } else {
@@ -1028,7 +1028,7 @@ pub fn handle_inlay_hints(
    let analysis = world.analysis();
    let line_index = analysis.file_line_index(file_id)?;
    Ok(analysis
-        .inlay_hints(file_id, &world.options.inlay_hints)?
+        .inlay_hints(file_id, &world.config.inlay_hints)?
        .into_iter()
        .map_conv_with(&line_index)
        .collect())
@@ -1145,7 +1145,7 @@ pub fn handle_semantic_tokens(
        }
    }
-    let tokens = SemanticTokens { data: builder.build(), ..Default::default() };
+    let tokens = builder.build();
    Ok(Some(tokens.into()))
 }
@@ -1166,7 +1166,7 @@ pub fn handle_semantic_tokens_range(
        builder.push(highlight_range.range.conv_with(&line_index), token_type, token_modifiers);
    }
-    let tokens = SemanticTokens { data: builder.build(), ..Default::default() };
+    let tokens = builder.build();
    Ok(Some(tokens.into()))
 }
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index 8557294f6..994f0ed61 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 pub use lsp_types::{
    notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
-    CodeLensParams, CompletionParams, CompletionResponse, DiagnosticTag,
+    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationParams, DiagnosticTag,
    DidChangeConfigurationParams, DidChangeWatchedFilesParams,
    DidChangeWatchedFilesRegistrationOptions, DocumentOnTypeFormattingParams, DocumentSymbolParams,
    DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index d9ba77050..2a66bbfd8 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -2,7 +2,7 @@
 use std::ops;
-use lsp_types::{Range, SemanticToken, SemanticTokenModifier, SemanticTokenType};
+use lsp_types::{Range, SemanticToken, SemanticTokenModifier, SemanticTokenType, SemanticTokens};
 pub(crate) const ATTRIBUTE: SemanticTokenType = SemanticTokenType::new("attribute");
 pub(crate) const BUILTIN_TYPE: SemanticTokenType = SemanticTokenType::new("builtinType");
@@ -109,8 +109,8 @@ impl SemanticTokensBuilder {
        self.prev_char = range.start.character as u32;
    }
-    pub fn build(self) -> Vec<SemanticToken> {
+    pub fn build(self) -> SemanticTokens {
-        self.data
+        SemanticTokens { result_id: None, data: self.data }
    }
 }
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 64a7b907e..7814a682e 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -11,9 +11,9 @@ use std::{
 use crossbeam_channel::{unbounded, Receiver};
 use lsp_types::Url;
 use parking_lot::RwLock;
-use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher};
+use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckConfig, Flycheck};
 use ra_ide::{
-    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, InlayHintsOptions, LibraryData,
+    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, InlayHintsConfig, LibraryData,
    SourceRootId,
 };
 use ra_project_model::{get_rustc_cfg_options, ProcMacroClient, ProjectWorkspace};
@@ -31,15 +31,36 @@ use crate::{
 use ra_db::ExternSourceId;
 use rustc_hash::{FxHashMap, FxHashSet};
+fn create_flycheck(workspaces: &[ProjectWorkspace], config: &Config) -> Option<Flycheck> {
+    let check_config = config.check.as_ref()?;
+    // FIXME: Figure out the multi-workspace situation
+    workspaces
+        .iter()
+        .find_map(|w| match w {
+            ProjectWorkspace::Cargo { cargo, .. } => Some(cargo),
+            ProjectWorkspace::Json { .. } => None,
+        })
+        .map(|cargo| {
+            let cargo_project_root = cargo.workspace_root().to_path_buf();
+            Some(Flycheck::new(check_config.clone(), cargo_project_root))
+        })
+        .unwrap_or_else(|| {
+            log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
+            None
+        })
+}
 #[derive(Debug, Clone)]
-pub struct Options {
+pub struct Config {
    pub publish_decorations: bool,
    pub supports_location_link: bool,
    pub line_folding_only: bool,
-    pub inlay_hints: InlayHintsOptions,
+    pub inlay_hints: InlayHintsConfig,
    pub rustfmt_args: Vec<String>,
-    pub cargo_watch: CheckOptions,
+    pub check: Option<CheckConfig>,
    pub vscode_lldb: bool,
+    pub proc_macro_srv: Option<String>,
 }
 /// `WorldState` is the primary mutable state of the language server
@@ -49,23 +70,21 @@ pub struct Options {
 /// incremental salsa database.
 #[derive(Debug)]
 pub struct WorldState {
-    pub options: Options,
+    pub config: Config,
    pub feature_flags: Arc<FeatureFlags>,
-    //FIXME: this belongs to `LoopState` rather than to `WorldState`
-    pub roots_to_scan: usize,
    pub roots: Vec<PathBuf>,
    pub workspaces: Arc<Vec<ProjectWorkspace>>,
    pub analysis_host: AnalysisHost,
    pub vfs: Arc<RwLock<Vfs>>,
    pub task_receiver: Receiver<VfsTask>,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
-    pub check_watcher: CheckWatcher,
+    pub flycheck: Option<Flycheck>,
    pub diagnostics: DiagnosticCollection,
 }
 /// An immutable snapshot of the world's state at a point in time.
 pub struct WorldSnapshot {
-    pub options: Options,
+    pub config: Config,
    pub feature_flags: Arc<FeatureFlags>,
    pub workspaces: Arc<Vec<ProjectWorkspace>>,
    pub analysis: Analysis,
@@ -81,7 +100,7 @@ impl WorldState {
        lru_capacity: Option<usize>,
        exclude_globs: &[Glob],
        watch: Watch,
-        options: Options,
+        config: Config,
        feature_flags: FeatureFlags,
    ) -> WorldState {
        let mut change = AnalysisChange::new();
@@ -123,7 +142,7 @@ impl WorldState {
        let (task_sender, task_receiver) = unbounded();
        let task_sender = Box::new(move |t| task_sender.send(t).unwrap());
        let (mut vfs, vfs_roots) = Vfs::new(roots, task_sender, watch);
-        let roots_to_scan = vfs_roots.len();
        for r in vfs_roots {
            let vfs_root_path = vfs.root2path(r);
            let is_local = folder_roots.iter().any(|it| vfs_root_path.starts_with(it));
@@ -151,8 +170,23 @@ impl WorldState {
            vfs_file.map(|f| FileId(f.0))
        };
-        let proc_macro_client =
+        let proc_macro_client = match &config.proc_macro_srv {
-            ProcMacroClient::extern_process(std::path::Path::new("ra_proc_macro_srv"));
+            None => ProcMacroClient::dummy(),
+            Some(srv) => {
+                let path = Path::new(&srv);
+                match ProcMacroClient::extern_process(path) {
+                    Ok(it) => it,
+                    Err(err) => {
+                        log::error!(
+                            "Fail to run ra_proc_macro_srv from path {}, error : {}",
+                            path.to_string_lossy(),
+                            err
+                        );
+                        ProcMacroClient::dummy()
+                    }
+                }
+            }
+        };
        workspaces
            .iter()
@@ -169,43 +203,41 @@ impl WorldState {
            });
        change.set_crate_graph(crate_graph);
-        // FIXME: Figure out the multi-workspace situation
+        let flycheck = create_flycheck(&workspaces, &config);
-        let check_watcher = workspaces
-            .iter()
-            .find_map(|w| match w {
-                ProjectWorkspace::Cargo { cargo, .. } => Some(cargo),
-                ProjectWorkspace::Json { .. } => None,
-            })
-            .map(|cargo| {
-                let cargo_project_root = cargo.workspace_root().to_path_buf();
-                CheckWatcher::new(&options.cargo_watch, cargo_project_root)
-            })
-            .unwrap_or_else(|| {
-                log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
-                CheckWatcher::dummy()
-            });
        let mut analysis_host = AnalysisHost::new(lru_capacity);
        analysis_host.apply_change(change);
        WorldState {
-            options,
+            config: config,
            feature_flags: Arc::new(feature_flags),
-            roots_to_scan,
            roots: folder_roots,
            workspaces: Arc::new(workspaces),
            analysis_host,
            vfs: Arc::new(RwLock::new(vfs)),
            task_receiver,
            latest_requests: Default::default(),
-            check_watcher,
+            flycheck,
            diagnostics: Default::default(),
        }
    }
+    pub fn update_configuration(
+        &mut self,
+        lru_capacity: Option<usize>,
+        config: Config,
+        feature_flags: FeatureFlags,
+    ) {
+        self.feature_flags = Arc::new(feature_flags);
+        self.analysis_host.update_lru_capacity(lru_capacity);
+        self.flycheck = create_flycheck(&self.workspaces, &config);
+        self.config = config;
+    }
    /// Returns a vec of libraries
    /// FIXME: better API here
    pub fn process_changes(
        &mut self,
+        roots_scanned: &mut usize,
    ) -> Option<Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>> {
        let changes = self.vfs.write().commit_changes();
        if changes.is_empty() {
@@ -219,7 +251,7 @@ impl WorldState {
                    let root_path = self.vfs.read().root2path(root);
                    let is_local = self.roots.iter().any(|r| root_path.starts_with(r));
                    if is_local {
-                        self.roots_to_scan -= 1;
+                        *roots_scanned += 1;
                        for (file, path, text) in files {
                            change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
                        }
@@ -247,7 +279,6 @@ impl WorldState {
    }
    pub fn add_lib(&mut self, data: LibraryData) {
-        self.roots_to_scan -= 1;
        let mut change = AnalysisChange::new();
        change.add_library(data);
        self.analysis_host.apply_change(change);
@@ -255,7 +286,7 @@ impl WorldState {
    pub fn snapshot(&self) -> WorldSnapshot {
        WorldSnapshot {
-            options: self.options.clone(),
+            config: self.config.clone(),
            feature_flags: Arc::clone(&self.feature_flags),
            workspaces: Arc::clone(&self.workspaces),
            analysis: self.analysis_host.analysis(),
diff --git a/crates/rust-analyzer/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs
index 145429571..5af5eaad2 100644
--- a/crates/rust-analyzer/tests/heavy_tests/main.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/main.rs
@@ -9,7 +9,7 @@ use lsp_types::{
 };
 use rust_analyzer::req::{
    CodeActionParams, CodeActionRequest, Completion, CompletionParams, DidOpenTextDocument,
-    Formatting, OnEnter, Runnables, RunnablesParams,
+    Formatting, GotoDefinition, OnEnter, Runnables, RunnablesParams,
 };
 use serde_json::json;
 use tempfile::TempDir;
@@ -581,3 +581,47 @@ version = \"0.0.0\"
        }),
    );
 }
+#[test]
+fn resolve_include_concat_env() {
+    if skip_slow_tests() {
+        return;
+    }
+    let server = Project::with_fixture(
+        r###"
+//- Cargo.toml
+[package]
+name = "foo"
+version = "0.0.0"
+//- build.rs
+use std::{env, fs, path::Path};
+fn main() {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("hello.rs");
+    fs::write(
+        &dest_path,
+        r#"pub fn message() -> &'static str { "Hello, World!" }"#,
+    )
+    .unwrap();
+    println!("cargo:rerun-if-changed=build.rs");
+}
+//- src/main.rs
+include!(concat!(env!("OUT_DIR"), "/hello.rs"));
+fn main() { message(); }
+"###,
+    )
+    .with_config(|config| {
+        config.cargo_features.load_out_dirs_from_check = true;
+    })
+    .server();
+    server.wait_until_workspace_is_loaded();
+    let res = server.send_request::<GotoDefinition>(TextDocumentPositionParams::new(
+        server.doc_id("src/main.rs"),
+        Position::new(2, 15),
+    ));
+    assert!(format!("{}", res).contains("hello.rs"));
+}
diff --git a/crates/rust-analyzer/tests/heavy_tests/support.rs b/crates/rust-analyzer/tests/heavy_tests/support.rs
index 1d7062bdf..d8bed6d7f 100644
--- a/crates/rust-analyzer/tests/heavy_tests/support.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/support.rs
@@ -27,11 +27,12 @@ pub struct Project<'a> {
    with_sysroot: bool,
    tmp_dir: Option<TempDir>,
    roots: Vec<PathBuf>,
+    config: Option<Box<dyn Fn(&mut ServerConfig)>>,
 }
 impl<'a> Project<'a> {
    pub fn with_fixture(fixture: &str) -> Project {
-        Project { fixture, tmp_dir: None, roots: vec![], with_sysroot: false }
+        Project { fixture, tmp_dir: None, roots: vec![], with_sysroot: false, config: None }
    }
    pub fn tmp_dir(mut self, tmp_dir: TempDir) -> Project<'a> {
@@ -49,6 +50,11 @@ impl<'a> Project<'a> {
        self
    }
+    pub fn with_config(mut self, config: impl Fn(&mut ServerConfig) + 'static) -> Project<'a> {
+        self.config = Some(Box::new(config));
+        self
+    }
    pub fn server(self) -> Server {
        let tmp_dir = self.tmp_dir.unwrap_or_else(|| TempDir::new().unwrap());
        static INIT: Once = Once::new();
@@ -72,7 +78,14 @@ impl<'a> Project<'a> {
        let roots = self.roots.into_iter().map(|root| tmp_dir.path().join(root)).collect();
-        Server::new(tmp_dir, self.with_sysroot, roots, paths)
+        let mut config =
+            ServerConfig { with_sysroot: self.with_sysroot, ..ServerConfig::default() };
+        if let Some(f) = &self.config {
+            f(&mut config)
+        }
+        Server::new(tmp_dir, config, roots, paths)
    }
 }
@@ -83,15 +96,16 @@ pub fn project(fixture: &str) -> Server {
 pub struct Server {
    req_id: Cell<u64>,
    messages: RefCell<Vec<Message>>,
-    dir: TempDir,
    _thread: jod_thread::JoinHandle<()>,
    client: Connection,
+    /// XXX: remove the tempdir last
+    dir: TempDir,
 }
 impl Server {
    fn new(
        dir: TempDir,
-        with_sysroot: bool,
+        config: ServerConfig,
        roots: Vec<PathBuf>,
        files: Vec<(PathBuf, String)>,
    ) -> Server {
@@ -117,7 +131,7 @@ impl Server {
                        window: None,
                        experimental: None,
                    },
-                    ServerConfig { with_sysroot, ..ServerConfig::default() },
+                    config,
                    connection,
                )
                .unwrap()
@@ -187,6 +201,7 @@ impl Server {
        self.client.sender.send(r.into()).unwrap();
        while let Some(msg) = self.recv() {
            match msg {
+                Message::Request(req) if req.method == "window/workDoneProgress/create" => (),
                Message::Request(req) => panic!("unexpected request: {:?}", req),
                Message::Notification(_) => (),
                Message::Response(res) => {
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 8492c17af..d2efa2236 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -5,7 +5,7 @@ use std::{cell::Cell, fmt};
 /// Appends formatted string to a `String`.
 #[macro_export]
 macro_rules! format_to {
-    (&buf:expr) => ();
+    ($buf:expr) => ();
    ($buf:expr, $lit:literal $($arg:tt)*) => {
        { use ::std::fmt::Write as _; let _ = ::std::write!($buf, $lit $($arg)*); }
    };