45 files changed, 1629 insertions, 1391 deletions
diff --git a/Cargo.lock b/Cargo.lock
index b2b624212..044314a8f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1395,6 +1395,7 @@ dependencies = [
 "ra_project_model",
 "ra_syntax",
 "ra_text_edit",
+ "ra_toolchain",
 "ra_tt",
 "rand",
 "rustc-hash",
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 9e8205ae7..92ec4f92e 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -7,7 +7,7 @@ use std::{
    io::{self, BufReader},
    path::PathBuf,
    process::{Command, Stdio},
-    time::Instant,
+    time::Duration,
 };
 use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
@@ -74,9 +74,6 @@ impl FlycheckHandle {
 #[derive(Debug)]
 pub enum Message {
-    /// Request a clearing of all cached diagnostics from the check watcher
-    ClearDiagnostics,
    /// Request adding a diagnostic with fixes included to a file
    AddDiagnostic { workspace_root: PathBuf, diagnostic: Diagnostic },
@@ -86,9 +83,10 @@ pub enum Message {
 #[derive(Debug)]
 pub enum Progress {
-    Being,
+    DidStart,
    DidCheckCrate(String),
-    End,
+    DidFinish,
+    DidCancel,
 }
 struct Restart;
@@ -97,19 +95,18 @@ struct FlycheckActor {
    sender: Box<dyn Fn(Message) + Send>,
    config: FlycheckConfig,
    workspace_root: PathBuf,
-    last_update_req: Option<Instant>,
    /// 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.
    // XXX: drop order is significant
-    check_process: Option<(Receiver<CheckEvent>, jod_thread::JoinHandle)>,
+    check_process: Option<(Receiver<cargo_metadata::Message>, jod_thread::JoinHandle)>,
 }
 enum Event {
    Restart(Restart),
-    CheckEvent(Option<CheckEvent>),
+    CheckEvent(Option<cargo_metadata::Message>),
 }
 impl FlycheckActor {
@@ -118,78 +115,58 @@ impl FlycheckActor {
        config: FlycheckConfig,
        workspace_root: PathBuf,
    ) -> FlycheckActor {
-        FlycheckActor { sender, config, workspace_root, last_update_req: None, check_process: None }
+        FlycheckActor { sender, config, workspace_root, check_process: None }
+    }
+    fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
+        let check_chan = self.check_process.as_ref().map(|(chan, _thread)| chan);
+        select! {
+            recv(inbox) -> msg => msg.ok().map(Event::Restart),
+            recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),
+        }
    }
    fn run(&mut self, inbox: Receiver<Restart>) {
-        // If we rerun the thread, we need to discard the previous check results first
-        self.send(Message::ClearDiagnostics);
-        self.send(Message::Progress(Progress::End));
        while let Some(event) = self.next_event(&inbox) {
            match event {
-                Event::Restart(Restart) => self.last_update_req = Some(Instant::now()),
+                Event::Restart(Restart) => {
+                    while let Ok(Restart) = inbox.recv_timeout(Duration::from_millis(50)) {}
+                    self.cancel_check_process();
+                    self.check_process = Some(self.start_check_process());
+                    self.send(Message::Progress(Progress::DidStart));
+                }
                Event::CheckEvent(None) => {
                    // Watcher finished, replace it with a never channel to
                    // avoid busy-waiting.
-                    self.check_process = None;
+                    assert!(self.check_process.take().is_some());
+                    self.send(Message::Progress(Progress::DidFinish));
                }
-                Event::CheckEvent(Some(event)) => match event {
+                Event::CheckEvent(Some(message)) => match message {
-                    CheckEvent::Begin => {
+                    cargo_metadata::Message::CompilerArtifact(msg) => {
-                        self.send(Message::Progress(Progress::Being));
-                    }
-                    CheckEvent::End => {
-                        self.send(Message::Progress(Progress::End));
-                    }
-                    CheckEvent::Msg(cargo_metadata::Message::CompilerArtifact(msg)) => {
                        self.send(Message::Progress(Progress::DidCheckCrate(msg.target.name)));
                    }
-                    CheckEvent::Msg(cargo_metadata::Message::CompilerMessage(msg)) => {
+                    cargo_metadata::Message::CompilerMessage(msg) => {
                        self.send(Message::AddDiagnostic {
                            workspace_root: self.workspace_root.clone(),
                            diagnostic: msg.message,
                        });
                    }
-                    CheckEvent::Msg(cargo_metadata::Message::BuildScriptExecuted(_))
+                    cargo_metadata::Message::BuildScriptExecuted(_)
-                    | CheckEvent::Msg(cargo_metadata::Message::BuildFinished(_))
+                    | cargo_metadata::Message::BuildFinished(_)
-                    | CheckEvent::Msg(cargo_metadata::Message::TextLine(_))
+                    | cargo_metadata::Message::TextLine(_)
-                    | CheckEvent::Msg(cargo_metadata::Message::Unknown) => {}
+                    | cargo_metadata::Message::Unknown => {}
                },
            }
-            if self.should_recheck() {
-                self.last_update_req = None;
-                self.send(Message::ClearDiagnostics);
-                self.restart_check_process();
-            }
-        }
-    }
-    fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
-        let check_chan = self.check_process.as_ref().map(|(chan, _thread)| chan);
-        select! {
-            recv(inbox) -> msg => msg.ok().map(Event::Restart),
-            recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),
        }
+        // If we rerun the thread, we need to discard the previous check results first
+        self.cancel_check_process();
    }
+    fn cancel_check_process(&mut self) {
-    fn should_recheck(&mut self) -> bool {
+        if self.check_process.take().is_some() {
-        if let Some(_last_update_req) = &self.last_update_req {
+            self.send(Message::Progress(Progress::DidCancel));
-            // We currently only request an update on save, as we need up to
-            // date source on disk for cargo check to do it's magic, so we
-            // don't really need to debounce the requests at this point.
-            return true;
        }
-        false
    }
+    fn start_check_process(&self) -> (Receiver<cargo_metadata::Message>, jod_thread::JoinHandle) {
-    fn restart_check_process(&mut self) {
-        // First, clear and cancel the old thread
-        self.check_process = None;
        let mut cmd = match &self.config {
            FlycheckConfig::CargoCommand {
                command,
@@ -226,8 +203,6 @@ impl FlycheckActor {
        let thread = 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(cmd, &mut |message| {
                // Skip certain kinds of messages to only spend time on what's useful
                match &message {
@@ -240,7 +215,7 @@ impl FlycheckActor {
                }
                // if the send channel was closed, we want to shutdown
-                message_send.send(CheckEvent::Msg(message)).is_ok()
+                message_send.send(message).is_ok()
            });
            if let Err(err) = res {
@@ -248,12 +223,8 @@ impl FlycheckActor {
                // 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);
        });
-        self.check_process = Some((message_recv, thread))
+        (message_recv, thread)
    }
    fn send(&self, check_task: Message) {
@@ -261,12 +232,6 @@ impl FlycheckActor {
    }
 }
-enum CheckEvent {
-    Begin,
-    Msg(cargo_metadata::Message),
-    End,
-}
 fn run_cargo(
    mut command: Command,
    on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index c6baa0a57..855baf187 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -4,6 +4,7 @@ use ra_syntax::{
 };
 use crate::{AssistContext, AssistId, Assists};
+use test_utils::mark;
 // Assist: change_return_type_to_result
 //
@@ -22,8 +23,13 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex
    let fn_def = ret_type.syntax().parent().and_then(ast::FnDef::cast)?;
    let type_ref = &ret_type.type_ref()?;
-    if type_ref.syntax().text().to_string().starts_with("Result<") {
+    let ret_type_str = type_ref.syntax().text().to_string();
-        return None;
+    let first_part_ret_type = ret_type_str.splitn(2, '<').next();
+    if let Some(ret_type_first_part) = first_part_ret_type {
+        if ret_type_first_part.ends_with("Result") {
+            mark::hit!(change_return_type_to_result_simple_return_type_already_result);
+            return None;
+        }
    }
    let block_expr = &fn_def.body()?;
@@ -297,6 +303,29 @@ mod tests {
    }
    #[test]
+    fn change_return_type_to_result_simple_return_type_already_result_std() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> std::result::Result<i32<|>, String> {
+                let test = "test";
+                return 42i32;
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_return_type_already_result() {
+        mark::check!(change_return_type_to_result_simple_return_type_already_result);
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> Result<i32<|>, String> {
+                let test = "test";
+                return 42i32;
+            }"#,
+        );
+    }
+    #[test]
    fn change_return_type_to_result_simple_with_cursor() {
        check_assist(
            change_return_type_to_result,
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/extract_variable.rs
index 88b62278f..c4150d2bb 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/extract_variable.rs
@@ -11,7 +11,7 @@ use test_utils::mark;
 use crate::{AssistContext, AssistId, Assists};
-// Assist: introduce_variable
+// Assist: extract_variable
 //
 // Extracts subexpression into a variable.
 //
@@ -27,13 +27,13 @@ use crate::{AssistContext, AssistId, Assists};
 //     var_name * 4;
 // }
 // ```
-pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    if ctx.frange.range.is_empty() {
        return None;
    }
    let node = ctx.covering_element();
    if node.kind() == COMMENT {
-        mark::hit!(introduce_var_in_comment_is_not_applicable);
+        mark::hit!(extract_var_in_comment_is_not_applicable);
        return None;
    }
    let expr = node.ancestors().find_map(valid_target_expr)?;
@@ -43,13 +43,27 @@ pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Opti
        return None;
    }
    let target = expr.syntax().text_range();
-    acc.add(AssistId("introduce_variable"), "Extract into variable", target, move |edit| {
+    acc.add(AssistId("extract_variable"), "Extract into variable", target, move |edit| {
+        let field_shorthand = match expr.syntax().parent().and_then(ast::RecordField::cast) {
+            Some(field) => field.name_ref(),
+            None => None,
+        };
        let mut buf = String::new();
+        let var_name = match &field_shorthand {
+            Some(it) => it.to_string(),
+            None => "var_name".to_string(),
+        };
+        let expr_range = match &field_shorthand {
+            Some(it) => it.syntax().text_range().cover(expr.syntax().text_range()),
+            None => expr.syntax().text_range(),
+        };
        if wrap_in_block {
-            buf.push_str("{ let var_name = ");
+            format_to!(buf, "{{ let {} = ", var_name);
        } else {
-            buf.push_str("let var_name = ");
+            format_to!(buf, "let {} = ", var_name);
        };
        format_to!(buf, "{}", expr.syntax());
@@ -60,17 +74,17 @@ pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Opti
            false
        };
        if is_full_stmt {
-            mark::hit!(test_introduce_var_expr_stmt);
+            mark::hit!(test_extract_var_expr_stmt);
            if full_stmt.unwrap().semicolon_token().is_none() {
                buf.push_str(";");
            }
-            let offset = expr.syntax().text_range();
            match ctx.config.snippet_cap {
                Some(cap) => {
-                    let snip = buf.replace("let var_name", "let $0var_name");
+                    let snip =
-                    edit.replace_snippet(cap, offset, snip)
+                        buf.replace(&format!("let {}", var_name), &format!("let $0{}", var_name));
+                    edit.replace_snippet(cap, expr_range, snip)
                }
-                None => edit.replace(offset, buf),
+                None => edit.replace(expr_range, buf),
            }
            return;
        }
@@ -88,11 +102,12 @@ pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Opti
            buf.push_str(text);
        }
-        edit.replace(expr.syntax().text_range(), "var_name".to_string());
+        edit.replace(expr_range, var_name.clone());
        let offset = anchor_stmt.text_range().start();
        match ctx.config.snippet_cap {
            Some(cap) => {
-                let snip = buf.replace("let var_name", "let $0var_name");
+                let snip =
+                    buf.replace(&format!("let {}", var_name), &format!("let $0{}", var_name));
                edit.insert_snippet(cap, offset, snip)
            }
            None => edit.insert(offset, buf),
@@ -118,7 +133,7 @@ fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
    }
 }
-/// Returns the syntax node which will follow the freshly introduced var
+/// Returns the syntax node which will follow the freshly extractd var
 /// and a boolean indicating whether we have to wrap it within a { } block
 /// to produce correct code.
 /// It can be a statement, the last in a block expression or a wanna be block
@@ -127,7 +142,7 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
    expr.syntax().ancestors().find_map(|node| {
        if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
            if expr.syntax() == &node {
-                mark::hit!(test_introduce_var_last_expr);
+                mark::hit!(test_extract_var_last_expr);
                return Some((node, false));
            }
        }
@@ -155,9 +170,9 @@ mod tests {
    use super::*;
    #[test]
-    fn test_introduce_var_simple() {
+    fn test_extract_var_simple() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 fn foo() {
    foo(<|>1 + 1<|>);
@@ -171,16 +186,16 @@ fn foo() {
    }
    #[test]
-    fn introduce_var_in_comment_is_not_applicable() {
+    fn extract_var_in_comment_is_not_applicable() {
-        mark::check!(introduce_var_in_comment_is_not_applicable);
+        mark::check!(extract_var_in_comment_is_not_applicable);
-        check_assist_not_applicable(introduce_variable, "fn main() { 1 + /* <|>comment<|> */ 1; }");
+        check_assist_not_applicable(extract_variable, "fn main() { 1 + /* <|>comment<|> */ 1; }");
    }
    #[test]
-    fn test_introduce_var_expr_stmt() {
+    fn test_extract_var_expr_stmt() {
-        mark::check!(test_introduce_var_expr_stmt);
+        mark::check!(test_extract_var_expr_stmt);
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 fn foo() {
    <|>1 + 1<|>;
@@ -191,7 +206,7 @@ fn foo() {
 }"#,
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() {
    <|>{ let x = 0; x }<|>
@@ -206,9 +221,9 @@ fn foo() {
    }
    #[test]
-    fn test_introduce_var_part_of_expr_stmt() {
+    fn test_extract_var_part_of_expr_stmt() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() {
    <|>1<|> + 1;
@@ -222,10 +237,10 @@ fn foo() {
    }
    #[test]
-    fn test_introduce_var_last_expr() {
+    fn test_extract_var_last_expr() {
-        mark::check!(test_introduce_var_last_expr);
+        mark::check!(test_extract_var_last_expr);
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 fn foo() {
    bar(<|>1 + 1<|>)
@@ -239,7 +254,7 @@ fn foo() {
 "#,
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 fn foo() {
    <|>bar(1 + 1)<|>
@@ -255,9 +270,9 @@ fn foo() {
    }
    #[test]
-    fn test_introduce_var_in_match_arm_no_block() {
+    fn test_extract_var_in_match_arm_no_block() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let x = true;
@@ -280,9 +295,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_in_match_arm_with_block() {
+    fn test_extract_var_in_match_arm_with_block() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let x = true;
@@ -312,9 +327,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_in_closure_no_block() {
+    fn test_extract_var_in_closure_no_block() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let lambda = |x: u32| <|>x * 2<|>;
@@ -329,9 +344,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_in_closure_with_block() {
+    fn test_extract_var_in_closure_with_block() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let lambda = |x: u32| { <|>x * 2<|> };
@@ -346,9 +361,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_path_simple() {
+    fn test_extract_var_path_simple() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let o = <|>Some(true)<|>;
@@ -364,9 +379,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_path_method() {
+    fn test_extract_var_path_method() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let v = <|>bar.foo()<|>;
@@ -382,9 +397,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_return() {
+    fn test_extract_var_return() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
    <|>return 2 + 2<|>;
@@ -400,9 +415,9 @@ fn foo() -> u32 {
    }
    #[test]
-    fn test_introduce_var_does_not_add_extra_whitespace() {
+    fn test_extract_var_does_not_add_extra_whitespace() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
@@ -421,7 +436,7 @@ fn foo() -> u32 {
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
@@ -438,7 +453,7 @@ fn foo() -> u32 {
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
    let foo = 1;
@@ -464,9 +479,9 @@ fn foo() -> u32 {
    }
    #[test]
-    fn test_introduce_var_break() {
+    fn test_extract_var_break() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let result = loop {
@@ -486,9 +501,9 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_for_cast() {
+    fn test_extract_var_for_cast() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let v = <|>0f32 as u32<|>;
@@ -504,22 +519,48 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_for_return_not_applicable() {
+    fn extract_var_field_shorthand() {
-        check_assist_not_applicable(introduce_variable, "fn foo() { <|>return<|>; } ");
+        check_assist(
+            extract_variable,
+            r#"
+struct S {
+    foo: i32
+}
+fn main() {
+    S { foo: <|>1 + 1<|> }
+}
+"#,
+            r#"
+struct S {
+    foo: i32
+}
+fn main() {
+    let $0foo = 1 + 1;
+    S { foo }
+}
+"#,
+        )
+    }
+    #[test]
+    fn test_extract_var_for_return_not_applicable() {
+        check_assist_not_applicable(extract_variable, "fn foo() { <|>return<|>; } ");
    }
    #[test]
-    fn test_introduce_var_for_break_not_applicable() {
+    fn test_extract_var_for_break_not_applicable() {
-        check_assist_not_applicable(introduce_variable, "fn main() { loop { <|>break<|>; }; }");
+        check_assist_not_applicable(extract_variable, "fn main() { loop { <|>break<|>; }; }");
    }
    // FIXME: This is not quite correct, but good enough(tm) for the sorting heuristic
    #[test]
-    fn introduce_var_target() {
+    fn extract_var_target() {
-        check_assist_target(introduce_variable, "fn foo() -> u32 { <|>return 2 + 2<|>; }", "2 + 2");
+        check_assist_target(extract_variable, "fn foo() -> u32 { <|>return 2 + 2<|>; }", "2 + 2");
        check_assist_target(
-            introduce_variable,
+            extract_variable,
            "
 fn main() {
    let x = true;
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 185428bd5..1745f44a5 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -116,6 +116,7 @@ mod handlers {
    mod change_visibility;
    mod early_return;
    mod extract_struct_from_enum_variant;
+    mod extract_variable;
    mod fill_match_arms;
    mod fix_visibility;
    mod flip_binexpr;
@@ -123,7 +124,6 @@ mod handlers {
    mod flip_trait_bound;
    mod inline_local_variable;
    mod introduce_named_lifetime;
-    mod introduce_variable;
    mod invert_if;
    mod merge_imports;
    mod merge_match_arms;
@@ -157,6 +157,7 @@ mod handlers {
            change_visibility::change_visibility,
            early_return::convert_to_guarded_return,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
+            extract_variable::extract_variable,
            fill_match_arms::fill_match_arms,
            fix_visibility::fix_visibility,
            flip_binexpr::flip_binexpr,
@@ -164,7 +165,6 @@ mod handlers {
            flip_trait_bound::flip_trait_bound,
            inline_local_variable::inline_local_variable,
            introduce_named_lifetime::introduce_named_lifetime,
-            introduce_variable::introduce_variable,
            invert_if::invert_if,
            merge_imports::merge_imports,
            merge_match_arms::merge_match_arms,
diff --git a/crates/ra_assists/src/tests/generated.rs b/crates/ra_assists/src/tests/generated.rs
index 40a223727..31ea888c5 100644
--- a/crates/ra_assists/src/tests/generated.rs
+++ b/crates/ra_assists/src/tests/generated.rs
@@ -353,6 +353,24 @@ enum A { One(One) }
 }
 #[test]
+fn doctest_extract_variable() {
+    check_doc_test(
+        "extract_variable",
+        r#####"
+fn main() {
+    <|>(1 + 2)<|> * 4;
+}
+"#####,
+        r#####"
+fn main() {
+    let $0var_name = (1 + 2);
+    var_name * 4;
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_fill_match_arms() {
    check_doc_test(
        "fill_match_arms",
@@ -492,24 +510,6 @@ impl<'a> Cursor<'a> {
 }
 #[test]
-fn doctest_introduce_variable() {
-    check_doc_test(
-        "introduce_variable",
-        r#####"
-fn main() {
-    <|>(1 + 2)<|> * 4;
-}
-"#####,
-        r#####"
-fn main() {
-    let $0var_name = (1 + 2);
-    var_name * 4;
-}
-"#####,
-    )
-}
-#[test]
 fn doctest_invert_if() {
    check_doc_test(
        "invert_if",
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 2bc34d449..4994a2125 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -8,12 +8,12 @@ use hir_expand::{
    InFile,
 };
 use ra_arena::{map::ArenaMap, Arena};
-use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
    body::{CfgExpander, LowerCtx},
    db::DefDatabase,
+    item_tree::{Field, Fields, ItemTree},
    src::HasChildSource,
    src::HasSource,
    trace::Trace,
@@ -22,6 +22,7 @@ use crate::{
    EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
    VariantId,
 };
+use ra_cfg::CfgOptions;
 /// Note that we use `StructData` for unions as well!
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -59,39 +60,48 @@ pub struct FieldData {
 impl StructData {
    pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
-        let src = id.lookup(db).source(db);
+        let loc = id.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
+        let strukt = &item_tree[loc.id.value];
-        let variant_data =
+        let variant_data = lower_fields(&item_tree, &cfg_options, &strukt.fields);
-            VariantData::new(db, src.map(|s| s.kind()), id.lookup(db).container.module(db));
-        let variant_data = Arc::new(variant_data);
+        Arc::new(StructData { name: strukt.name.clone(), variant_data: Arc::new(variant_data) })
-        Arc::new(StructData { name, variant_data })
    }
    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
-        let src = id.lookup(db).source(db);
+        let loc = id.lookup(db);
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
+        let item_tree = db.item_tree(loc.id.file_id);
-        let variant_data = VariantData::new(
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
-            db,
-            src.map(|s| {
+        let union = &item_tree[loc.id.value];
-                s.record_field_def_list()
+        let variant_data = lower_fields(&item_tree, &cfg_options, &union.fields);
-                    .map(ast::StructKind::Record)
-                    .unwrap_or(ast::StructKind::Unit)
+        Arc::new(StructData { name: union.name.clone(), variant_data: Arc::new(variant_data) })
-            }),
-            id.lookup(db).container.module(db),
-        );
-        let variant_data = Arc::new(variant_data);
-        Arc::new(StructData { name, variant_data })
    }
 }
 impl EnumData {
    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
-        let _p = profile("enum_data_query");
+        let loc = e.lookup(db);
-        let src = e.lookup(db).source(db);
+        let item_tree = db.item_tree(loc.id.file_id);
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
-        let mut trace = Trace::new_for_arena();
-        lower_enum(db, &mut trace, &src, e.lookup(db).container.module(db));
+        let enum_ = &item_tree[loc.id.value];
-        Arc::new(EnumData { name, variants: trace.into_arena() })
+        let mut variants = Arena::new();
+        for var_id in enum_.variants.clone() {
+            if item_tree.attrs(var_id.into()).is_cfg_enabled(&cfg_options) {
+                let var = &item_tree[var_id];
+                let var_data = lower_fields(&item_tree, &cfg_options, &var.fields);
+                variants.alloc(EnumVariantData {
+                    name: var.name.clone(),
+                    variant_data: Arc::new(var_data),
+                });
+            }
+        }
+        Arc::new(EnumData { name: enum_.name.clone(), variants })
    }
    pub fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
@@ -251,3 +261,35 @@ fn lower_struct(
        ast::StructKind::Unit => StructKind::Unit,
    }
 }
+fn lower_fields(item_tree: &ItemTree, cfg_options: &CfgOptions, fields: &Fields) -> VariantData {
+    match fields {
+        Fields::Record(flds) => {
+            let mut arena = Arena::new();
+            for field_id in flds.clone() {
+                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                }
+            }
+            VariantData::Record(arena)
+        }
+        Fields::Tuple(flds) => {
+            let mut arena = Arena::new();
+            for field_id in flds.clone() {
+                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                }
+            }
+            VariantData::Tuple(arena)
+        }
+        Fields::Unit => VariantData::Unit,
+    }
+}
+fn lower_field(item_tree: &ItemTree, field: &Field) -> FieldData {
+    FieldData {
+        name: field.name.clone(),
+        type_ref: field.type_ref.clone(),
+        visibility: item_tree[field.visibility].clone(),
+    }
+}
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 197737ffc..e228e2145 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -208,5 +208,5 @@ where
 fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> Attrs {
    let tree = db.item_tree(id.file_id);
    let mod_item = N::id_to_mod_item(id.value);
-    tree.attrs(mod_item).clone()
+    tree.attrs(mod_item.into()).clone()
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 3ced648e5..a7e2e0982 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -5,7 +5,7 @@ use either::Either;
 use hir_expand::{
    hygiene::Hygiene,
    name::{name, AsName, Name},
-    AstId, HirFileId, MacroDefId, MacroDefKind,
+    HirFileId, MacroDefId, MacroDefKind,
 };
 use ra_arena::Arena;
 use ra_syntax::{
@@ -27,7 +27,7 @@ use crate::{
        LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
    },
    item_scope::BuiltinShadowMode,
-    item_tree::{FileItemTreeId, ItemTree, ItemTreeNode},
+    item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
@@ -37,7 +37,7 @@ use crate::{
 use super::{ExprSource, PatSource};
 use ast::AstChildren;
 use rustc_hash::FxHashMap;
-use std::sync::Arc;
+use std::{any::type_name, sync::Arc};
 pub(crate) struct LowerCtx {
    hygiene: Hygiene,
@@ -561,17 +561,30 @@ impl ExprCollector<'_> {
        }
    }
-    fn find_inner_item<S: ItemTreeNode>(&self, id: AstId<ast::ModuleItem>) -> FileItemTreeId<S> {
+    fn find_inner_item<N: ItemTreeNode>(&self, ast: &N::Source) -> Option<ItemTreeId<N>> {
+        let id = self.expander.ast_id(ast);
        let tree = &self.item_trees[&id.file_id];
        // FIXME: This probably breaks with `use` items, since they produce multiple item tree nodes
        // Root file (non-macro).
-        tree.all_inner_items()
+        let item_tree_id = tree
+            .all_inner_items()
            .chain(tree.top_level_items().iter().copied())
-            .filter_map(|mod_item| mod_item.downcast::<S>())
+            .filter_map(|mod_item| mod_item.downcast::<N>())
-            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value)
+            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value.upcast())
-            .unwrap_or_else(|| panic!("couldn't find inner item for {:?}", id))
+            .or_else(|| {
+                log::debug!(
+                    "couldn't find inner {} item for {:?} (AST: `{}` - {:?})",
+                    type_name::<N>(),
+                    id,
+                    ast.syntax(),
+                    ast.syntax(),
+                );
+                None
+            })?;
+        Some(ItemTreeId::new(id.file_id, item_tree_id))
    }
    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
@@ -611,82 +624,45 @@ impl ExprCollector<'_> {
            .filter_map(|item| {
                let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
                    ast::ModuleItem::FnDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
                        (
-                            FunctionLoc { container: container.into(), id: ast_id.with_value(id) }
+                            FunctionLoc { container: container.into(), id }.intern(self.db).into(),
-                                .intern(self.db)
-                                .into(),
                            def.name(),
                        )
                    }
                    ast::ModuleItem::TypeAliasDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
                        (
-                            TypeAliasLoc { container: container.into(), id: ast_id.with_value(id) }
+                            TypeAliasLoc { container: container.into(), id }.intern(self.db).into(),
-                                .intern(self.db)
-                                .into(),
                            def.name(),
                        )
                    }
                    ast::ModuleItem::ConstDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
                        (
-                            ConstLoc { container: container.into(), id: ast_id.with_value(id) }
+                            ConstLoc { container: container.into(), id }.intern(self.db).into(),
-                                .intern(self.db)
-                                .into(),
                            def.name(),
                        )
                    }
                    ast::ModuleItem::StaticDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (StaticLoc { container, id }.intern(self.db).into(), def.name())
-                        (
-                            StaticLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
                    }
                    ast::ModuleItem::StructDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (StructLoc { container, id }.intern(self.db).into(), def.name())
-                        (
-                            StructLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
                    }
                    ast::ModuleItem::EnumDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (EnumLoc { container, id }.intern(self.db).into(), def.name())
-                        (
-                            EnumLoc { container, id: ast_id.with_value(id) }.intern(self.db).into(),
-                            def.name(),
-                        )
                    }
                    ast::ModuleItem::UnionDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (UnionLoc { container, id }.intern(self.db).into(), def.name())
-                        (
-                            UnionLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
                    }
                    ast::ModuleItem::TraitDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(&def)?;
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (TraitLoc { container, id }.intern(self.db).into(), def.name())
-                        (
-                            TraitLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
                    }
                    ast::ModuleItem::ExternBlock(_) => return None, // FIXME: collect from extern blocks
                    ast::ModuleItem::ImplDef(_)
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 81397b063..99e876683 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -337,6 +337,19 @@ fn foo() {
        );
    }
+    #[test]
+    fn broken_inner_item() {
+        do_check(
+            r"
+            fn foo() {
+                trait {}
+                <|>
+            }
+        ",
+            &[],
+        );
+    }
    fn do_check_local_name(ra_fixture: &str, expected_offset: u32) {
        let (db, position) = TestDB::with_position(ra_fixture);
        let file_id = position.file_id;
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index f9e5701db..282ade2a3 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -40,7 +40,7 @@ impl FunctionData {
            name: func.name.clone(),
            params: func.params.to_vec(),
            ret_type: func.ret_type.clone(),
-            attrs: item_tree.attrs(loc.id.value.into()).clone(),
+            attrs: item_tree.attrs(ModItem::from(loc.id.value).into()).clone(),
            has_self_param: func.has_self_param,
            is_unsafe: func.is_unsafe,
            visibility: item_tree[func.visibility].clone(),
@@ -224,7 +224,7 @@ fn collect_items(
        match item {
            AssocItem::Function(id) => {
                let item = &item_tree[id];
-                let attrs = item_tree.attrs(id.into());
+                let attrs = item_tree.attrs(ModItem::from(id).into());
                if !attrs.is_cfg_enabled(&cfg_options) {
                    continue;
                }
diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs
index d7bc64e6c..3e603bd55 100644
--- a/crates/ra_hir_def/src/item_tree.rs
+++ b/crates/ra_hir_def/src/item_tree.rs
@@ -5,6 +5,7 @@ mod lower;
 mod tests;
 use std::{
+    any::type_name,
    fmt::{self, Debug},
    hash::{Hash, Hasher},
    marker::PhantomData,
@@ -178,8 +179,8 @@ impl ItemTree {
        self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&Attrs::EMPTY)
    }
-    pub fn attrs(&self, of: ModItem) -> &Attrs {
+    pub fn attrs(&self, of: AttrOwner) -> &Attrs {
-        self.attrs.get(&AttrOwner::ModItem(of)).unwrap_or(&Attrs::EMPTY)
+        self.attrs.get(&of).unwrap_or(&Attrs::EMPTY)
    }
    /// Returns the lowered inner items that `ast` corresponds to.
@@ -282,15 +283,32 @@ struct ItemTreeData {
 }
 #[derive(Debug, Eq, PartialEq, Hash)]
-enum AttrOwner {
+pub enum AttrOwner {
    /// Attributes on an item.
    ModItem(ModItem),
    /// Inner attributes of the source file.
    TopLevel,
+    Variant(Idx<Variant>),
+    Field(Idx<Field>),
    // FIXME: Store variant and field attrs, and stop reparsing them in `attrs_query`.
 }
-/// Trait implemented by all nodes in the item tree.
+macro_rules! from_attrs {
+    ( $( $var:ident($t:ty) ),+ ) => {
+        $(
+            impl From<$t> for AttrOwner {
+                fn from(t: $t) -> AttrOwner {
+                    AttrOwner::$var(t)
+                }
+            }
+        )+
+    };
+}
+from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>));
+/// Trait implemented by all item nodes in the item tree.
 pub trait ItemTreeNode: Clone {
    type Source: AstNode + Into<ast::ModuleItem>;
@@ -523,7 +541,7 @@ pub struct Enum {
    pub name: Name,
    pub visibility: RawVisibilityId,
    pub generic_params: GenericParamsId,
-    pub variants: Range<Idx<Variant>>,
+    pub variants: IdRange<Variant>,
    pub ast_id: FileAstId<ast::EnumDef>,
 }
@@ -681,10 +699,48 @@ pub struct Variant {
    pub fields: Fields,
 }
+pub struct IdRange<T> {
+    range: Range<u32>,
+    _p: PhantomData<T>,
+}
+impl<T> IdRange<T> {
+    fn new(range: Range<Idx<T>>) -> Self {
+        Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData }
+    }
+}
+impl<T> Iterator for IdRange<T> {
+    type Item = Idx<T>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.range.next().map(|raw| Idx::from_raw(raw.into()))
+    }
+}
+impl<T> fmt::Debug for IdRange<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple(&format!("IdRange::<{}>", type_name::<T>())).field(&self.range).finish()
+    }
+}
+impl<T> Clone for IdRange<T> {
+    fn clone(&self) -> Self {
+        Self { range: self.range.clone(), _p: PhantomData }
+    }
+}
+impl<T> PartialEq for IdRange<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.range == other.range
+    }
+}
+impl<T> Eq for IdRange<T> {}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Fields {
-    Record(Range<Idx<Field>>),
+    Record(IdRange<Field>),
-    Tuple(Range<Idx<Field>>),
+    Tuple(IdRange<Field>),
    Unit,
 }
diff --git a/crates/ra_hir_def/src/item_tree/lower.rs b/crates/ra_hir_def/src/item_tree/lower.rs
index f10ad25f7..5149dd141 100644
--- a/crates/ra_hir_def/src/item_tree/lower.rs
+++ b/crates/ra_hir_def/src/item_tree/lower.rs
@@ -126,15 +126,15 @@ impl Ctx {
        if !attrs.is_empty() {
            for item in items.iter().flat_map(|items| &items.0) {
-                self.add_attrs(*item, attrs.clone());
+                self.add_attrs((*item).into(), attrs.clone());
            }
        }
        items
    }
-    fn add_attrs(&mut self, item: ModItem, attrs: Attrs) {
+    fn add_attrs(&mut self, item: AttrOwner, attrs: Attrs) {
-        match self.tree.attrs.entry(AttrOwner::ModItem(item)) {
+        match self.tree.attrs.entry(item) {
            Entry::Occupied(mut entry) => {
                *entry.get_mut() = entry.get().merge(attrs);
            }
@@ -196,15 +196,16 @@ impl Ctx {
        }
    }
-    fn lower_record_fields(&mut self, fields: &ast::RecordFieldDefList) -> Range<Idx<Field>> {
+    fn lower_record_fields(&mut self, fields: &ast::RecordFieldDefList) -> IdRange<Field> {
        let start = self.next_field_idx();
        for field in fields.fields() {
            if let Some(data) = self.lower_record_field(&field) {
-                self.data().fields.alloc(data);
+                let idx = self.data().fields.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
            }
        }
        let end = self.next_field_idx();
-        start..end
+        IdRange::new(start..end)
    }
    fn lower_record_field(&mut self, field: &ast::RecordFieldDef) -> Option<Field> {
@@ -215,15 +216,16 @@ impl Ctx {
        Some(res)
    }
-    fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldDefList) -> Range<Idx<Field>> {
+    fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldDefList) -> IdRange<Field> {
        let start = self.next_field_idx();
        for (i, field) in fields.fields().enumerate() {
            if let Some(data) = self.lower_tuple_field(i, &field) {
-                self.data().fields.alloc(data);
+                let idx = self.data().fields.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
            }
        }
        let end = self.next_field_idx();
-        start..end
+        IdRange::new(start..end)
    }
    fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleFieldDef) -> Option<Field> {
@@ -242,7 +244,7 @@ impl Ctx {
            Some(record_field_def_list) => {
                self.lower_fields(&StructKind::Record(record_field_def_list))
            }
-            None => Fields::Record(self.next_field_idx()..self.next_field_idx()),
+            None => Fields::Record(IdRange::new(self.next_field_idx()..self.next_field_idx())),
        };
        let ast_id = self.source_ast_id_map.ast_id(union);
        let res = Union { name, visibility, generic_params, fields, ast_id };
@@ -255,22 +257,23 @@ impl Ctx {
        let generic_params = self.lower_generic_params(GenericsOwner::Enum, enum_);
        let variants = match &enum_.variant_list() {
            Some(variant_list) => self.lower_variants(variant_list),
-            None => self.next_variant_idx()..self.next_variant_idx(),
+            None => IdRange::new(self.next_variant_idx()..self.next_variant_idx()),
        };
        let ast_id = self.source_ast_id_map.ast_id(enum_);
        let res = Enum { name, visibility, generic_params, variants, ast_id };
        Some(id(self.data().enums.alloc(res)))
    }
-    fn lower_variants(&mut self, variants: &ast::EnumVariantList) -> Range<Idx<Variant>> {
+    fn lower_variants(&mut self, variants: &ast::EnumVariantList) -> IdRange<Variant> {
        let start = self.next_variant_idx();
        for variant in variants.variants() {
            if let Some(data) = self.lower_variant(&variant) {
-                self.data().variants.alloc(data);
+                let idx = self.data().variants.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&variant, &self.hygiene));
            }
        }
        let end = self.next_variant_idx();
-        start..end
+        IdRange::new(start..end)
    }
    fn lower_variant(&mut self, variant: &ast::EnumVariant) -> Option<Variant> {
@@ -419,7 +422,7 @@ impl Ctx {
                        let attrs = Attrs::new(&item, &this.hygiene);
                        this.collect_inner_items(item.syntax());
                        this.lower_assoc_item(&item).map(|item| {
-                            this.add_attrs(item.into(), attrs);
+                            this.add_attrs(ModItem::from(item).into(), attrs);
                            item
                        })
                    })
@@ -453,7 +456,7 @@ impl Ctx {
                self.collect_inner_items(item.syntax());
                let assoc = self.lower_assoc_item(&item)?;
                let attrs = Attrs::new(&item, &self.hygiene);
-                self.add_attrs(assoc.into(), attrs);
+                self.add_attrs(ModItem::from(assoc).into(), attrs);
                Some(assoc)
            })
            .collect();
@@ -539,7 +542,7 @@ impl Ctx {
                .filter_map(|item| {
                    self.collect_inner_items(item.syntax());
                    let attrs = Attrs::new(&item, &self.hygiene);
-                    let id = match item {
+                    let id: ModItem = match item {
                        ast::ExternItem::FnDef(ast) => {
                            let func = self.lower_function(&ast)?;
                            func.into()
@@ -549,7 +552,7 @@ impl Ctx {
                            statik.into()
                        }
                    };
-                    self.add_attrs(id, attrs);
+                    self.add_attrs(id.into(), attrs);
                    Some(id)
                })
                .collect()
diff --git a/crates/ra_hir_def/src/item_tree/tests.rs b/crates/ra_hir_def/src/item_tree/tests.rs
index dc035d809..08559fb92 100644
--- a/crates/ra_hir_def/src/item_tree/tests.rs
+++ b/crates/ra_hir_def/src/item_tree/tests.rs
@@ -92,7 +92,7 @@ fn print_item_tree(ra_fixture: &str) -> String {
 }
 fn fmt_mod_item(out: &mut String, tree: &ItemTree, item: ModItem) {
-    let attrs = tree.attrs(item);
+    let attrs = tree.attrs(item.into());
    if !attrs.is_empty() {
        format_to!(out, "#[{:?}]\n", attrs);
    }
@@ -237,13 +237,13 @@ Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generi
 #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct0"))] }, input: None }]) }]
 Struct { name: Name(Text("Struct0")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), fields: Unit, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(3), kind: Unit }
 #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct1"))] }, input: None }]) }]
-Struct { name: Name(Text("Struct1")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(2), fields: Tuple(Idx::<Field>(0)..Idx::<Field>(1)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(4), kind: Tuple }
+Struct { name: Name(Text("Struct1")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(2), fields: Tuple(IdRange::<ra_hir_def::item_tree::Field>(0..1)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(4), kind: Tuple }
 #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct2"))] }, input: None }]) }]
-Struct { name: Name(Text("Struct2")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(3), fields: Record(Idx::<Field>(1)..Idx::<Field>(2)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(5), kind: Record }
+Struct { name: Name(Text("Struct2")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(3), fields: Record(IdRange::<ra_hir_def::item_tree::Field>(1..2)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(5), kind: Record }
 #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("en"))] }, input: None }]) }]
-Enum { name: Name(Text("En")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), variants: Idx::<Variant>(0)..Idx::<Variant>(1), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::EnumDef>(6) }
+Enum { name: Name(Text("En")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), variants: IdRange::<ra_hir_def::item_tree::Variant>(0..1), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::EnumDef>(6) }
 #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("un"))] }, input: None }]) }]
-Union { name: Name(Text("Un")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), fields: Record(Idx::<Field>(3)..Idx::<Field>(4)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::UnionDef>(7) }
+Union { name: Name(Text("Un")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), fields: Record(IdRange::<ra_hir_def::item_tree::Field>(3..4)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::UnionDef>(7) }
    "###);
 }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 5a0eba437..a35ac1024 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -764,7 +764,7 @@ impl ModCollector<'_, '_> {
        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
        // any other items.
        for item in items {
-            if self.is_cfg_enabled(self.item_tree.attrs(*item)) {
+            if self.is_cfg_enabled(self.item_tree.attrs((*item).into())) {
                if let ModItem::ExternCrate(id) = item {
                    let import = self.item_tree[*id].clone();
                    if import.is_macro_use {
@@ -775,7 +775,7 @@ impl ModCollector<'_, '_> {
        }
        for &item in items {
-            let attrs = self.item_tree.attrs(item);
+            let attrs = self.item_tree.attrs(item.into());
            if self.is_cfg_enabled(attrs) {
                let module =
                    ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index e9a5e4cba..753684201 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -335,6 +335,22 @@ fn module_resolution_relative_path_2() {
 }
 #[test]
+fn module_resolution_relative_path_outside_root() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path="../../../../../outside.rs"]
+        mod foo;
+        "###,
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+    "###);
+}
+#[test]
 fn module_resolution_explicit_path_mod_rs_2() {
    let map = def_map(
        r###"
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 23de2bd6b..4dd4f9802 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -184,7 +184,7 @@ impl<'a> InferenceContext<'a> {
                self.write_pat_ty(pat, bound_ty);
                return inner_ty;
            }
-            Pat::Slice { prefix, slice: _slice, suffix } => {
+            Pat::Slice { prefix, slice, suffix } => {
                let (container_ty, elem_ty) = match &expected {
                    ty_app!(TypeCtor::Array, st) => (TypeCtor::Array, st.as_single().clone()),
                    ty_app!(TypeCtor::Slice, st) => (TypeCtor::Slice, st.as_single().clone()),
@@ -195,7 +195,12 @@ impl<'a> InferenceContext<'a> {
                    self.infer_pat(*pat_id, &elem_ty, default_bm);
                }
-                Ty::apply_one(container_ty, elem_ty)
+                let pat_ty = Ty::apply_one(container_ty, elem_ty);
+                if let Some(slice_pat_id) = slice {
+                    self.infer_pat(*slice_pat_id, &pat_ty, default_bm);
+                }
+                pat_ty
            }
            Pat::Wild => expected.clone(),
            Pat::Range { start, end } => {
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 8b59a8bd6..c19519cf1 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -281,6 +281,7 @@ pub fn iterate_method_candidates<T>(
        name,
        mode,
        &mut |ty, item| {
+            assert!(slot.is_none());
            slot = callback(ty, item);
            slot.is_some()
        },
@@ -288,7 +289,7 @@ pub fn iterate_method_candidates<T>(
    slot
 }
-pub fn iterate_method_candidates_impl(
+fn iterate_method_candidates_impl(
    ty: &Canonical<Ty>,
    db: &dyn HirDatabase,
    env: Arc<TraitEnvironment>,
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index e5ef241ca..f937426bd 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -627,3 +627,28 @@ fn test() {
    "###
    );
 }
+#[test]
+fn slice_tail_pattern() {
+    assert_snapshot!(
+        infer(r#"
+fn foo(params: &[i32]) {
+    match params {
+        [head, tail @ ..] => {
+        }
+    }
+}
+"#),
+        @r###"
+    7..13 'params': &[i32]
+    23..92 '{     ...   } }': ()
+    29..90 'match ...     }': ()
+    35..41 'params': &[i32]
+    52..69 '[head,... @ ..]': [i32]
+    53..57 'head': &i32
+    59..68 'tail @ ..': &[i32]
+    66..68 '..': [i32]
+    73..84 '{         }': ()
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index eedaa27ba..aa37326df 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -500,6 +500,8 @@ fn foo(params: &[usize]) {
    31..78 'match ...     }': ()
    37..43 'params': &[usize]
    54..66 '[ps @ .., _]': [usize]
+    55..62 'ps @ ..': &[usize]
+    60..62 '..': [usize]
    64..65 '_': usize
    70..72 '{}': ()
    "###
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 4f59b0a23..d797f2cc9 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -127,17 +127,24 @@ impl<'t> Parser<'t> {
    fn at_composite2(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind) -> bool {
        let t1 = self.token_source.lookahead_nth(n);
+        if t1.kind != k1 || !t1.is_jointed_to_next {
+            return false;
+        }
        let t2 = self.token_source.lookahead_nth(n + 1);
-        t1.kind == k1 && t1.is_jointed_to_next && t2.kind == k2
+        t2.kind == k2
    }
    fn at_composite3(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind, k3: SyntaxKind) -> bool {
        let t1 = self.token_source.lookahead_nth(n);
+        if t1.kind != k1 || !t1.is_jointed_to_next {
+            return false;
+        }
        let t2 = self.token_source.lookahead_nth(n + 1);
+        if t2.kind != k2 || !t2.is_jointed_to_next {
+            return false;
+        }
        let t3 = self.token_source.lookahead_nth(n + 2);
-        (t1.kind == k1 && t1.is_jointed_to_next)
+        t3.kind == k3
-            && (t2.kind == k2 && t2.is_jointed_to_next)
-            && t3.kind == k3
    }
    /// Checks if the current token is in `kinds`.
diff --git a/crates/ra_toolchain/src/lib.rs b/crates/ra_toolchain/src/lib.rs
index 3d2865e09..9916e52c4 100644
--- a/crates/ra_toolchain/src/lib.rs
+++ b/crates/ra_toolchain/src/lib.rs
@@ -15,6 +15,10 @@ pub fn rustup() -> PathBuf {
    get_path_for_executable("rustup")
 }
+pub fn rustfmt() -> PathBuf {
+    get_path_for_executable("rustfmt")
+}
 /// Return a `PathBuf` to use for the given executable.
 ///
 /// E.g., `get_path_for_executable("cargo")` may return just `cargo` if that
@@ -42,22 +46,23 @@ fn get_path_for_executable(executable_name: &'static str) -> PathBuf {
        path.push(".cargo");
        path.push("bin");
        path.push(executable_name);
-        if path.is_file() {
+        if let Some(path) = probe(path) {
            return path;
        }
    }
    executable_name.into()
 }
 fn lookup_in_path(exec: &str) -> bool {
    let paths = env::var_os("PATH").unwrap_or_default();
-    let mut candidates = env::split_paths(&paths).flat_map(|path| {
+    env::split_paths(&paths).map(|path| path.join(exec)).find_map(probe).is_some()
-        let candidate = path.join(&exec);
+}
-        let with_exe = match env::consts::EXE_EXTENSION {
-            "" => None,
+fn probe(path: PathBuf) -> Option<PathBuf> {
-            it => Some(candidate.with_extension(it)),
+    let with_extension = match env::consts::EXE_EXTENSION {
-        };
+        "" => None,
-        iter::once(candidate).chain(with_exe)
+        it => Some(path.with_extension(it)),
-    });
+    };
-    candidates.any(|it| it.is_file())
+    iter::once(path).chain(with_extension).find(|it| it.is_file())
 }
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 08c67ddd0..122a1605f 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -41,6 +41,7 @@ ra_text_edit = { path = "../ra_text_edit" }
 vfs = { path = "../vfs" }
 vfs-notify = { path = "../vfs-notify" }
 ra_cfg = { path = "../ra_cfg"}
+ra_toolchain = { path = "../ra_toolchain" }
 # This should only be used in CLI
 ra_db = { path = "../ra_db" }
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index c5cf5ff27..d8677c231 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -9,7 +9,7 @@ use ra_ide::{AnalysisChange, AnalysisHost};
 use ra_project_model::{CargoConfig, ProcMacroClient, ProjectManifest, ProjectWorkspace};
 use vfs::{loader::Handle, AbsPath};
-use crate::global_state::{ProjectFolders, SourceRootConfig};
+use crate::reload::{ProjectFolders, SourceRootConfig};
 pub fn load_cargo(
    root: &Path,
@@ -54,7 +54,7 @@ pub fn load_cargo(
    Ok((host, vfs))
 }
-pub(crate) fn load(
+fn load(
    crate_graph: CrateGraph,
    source_root_config: SourceRootConfig,
    vfs: &mut vfs::Vfs,
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 435bbbb6b..6b17ce18b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -30,7 +30,7 @@ pub struct Config {
    pub cargo: CargoConfig,
    pub rustfmt: RustfmtConfig,
-    pub check: Option<FlycheckConfig>,
+    pub flycheck: Option<FlycheckConfig>,
    pub inlay_hints: InlayHintsConfig,
    pub completion: CompletionConfig,
@@ -147,7 +147,7 @@ impl Config {
            cargo: CargoConfig::default(),
            rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
-            check: Some(FlycheckConfig::CargoCommand {
+            flycheck: Some(FlycheckConfig::CargoCommand {
                command: "check".to_string(),
                all_targets: true,
                all_features: false,
@@ -227,14 +227,14 @@ impl Config {
        if let Some(false) = get(value, "/checkOnSave/enable") {
            // check is disabled
-            self.check = None;
+            self.flycheck = None;
        } else {
            // check is enabled
            match get::<Vec<String>>(value, "/checkOnSave/overrideCommand") {
                // first see if the user has completely overridden the command
                Some(mut args) if !args.is_empty() => {
                    let command = args.remove(0);
-                    self.check = Some(FlycheckConfig::CustomCommand {
+                    self.flycheck = Some(FlycheckConfig::CustomCommand {
                        command,
                        args,
                    });
@@ -242,7 +242,7 @@ impl Config {
                // otherwise configure command customizations
                _ => {
                    if let Some(FlycheckConfig::CargoCommand { command, extra_args, all_targets, all_features, features })
-                        = &mut self.check
+                        = &mut self.flycheck
                    {
                        set(value, "/checkOnSave/extraArgs", extra_args);
                        set(value, "/checkOnSave/command", command);
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index 290609e7f..1cf50b677 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -1,14 +1,14 @@
 //! Book keeping for keeping diagnostics easily in sync with the client.
 pub(crate) mod to_proto;
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, mem, sync::Arc};
-use lsp_types::{Diagnostic, Range};
 use ra_ide::FileId;
+use rustc_hash::FxHashSet;
 use crate::lsp_ext;
-pub type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
+pub(crate) type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
 #[derive(Debug, Default, Clone)]
 pub struct DiagnosticsConfig {
@@ -17,35 +17,29 @@ pub struct DiagnosticsConfig {
 }
 #[derive(Debug, Default, Clone)]
-pub struct DiagnosticCollection {
+pub(crate) struct DiagnosticCollection {
-    pub native: HashMap<FileId, Vec<Diagnostic>>,
+    pub(crate) native: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
-    pub check: HashMap<FileId, Vec<Diagnostic>>,
+    pub(crate) check: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
-    pub check_fixes: CheckFixes,
+    pub(crate) check_fixes: CheckFixes,
+    changes: FxHashSet<FileId>,
 }
 #[derive(Debug, Clone)]
-pub struct Fix {
+pub(crate) struct Fix {
-    pub range: Range,
+    pub(crate) range: lsp_types::Range,
-    pub action: lsp_ext::CodeAction,
+    pub(crate) action: lsp_ext::CodeAction,
-}
-#[derive(Debug)]
-pub enum DiagnosticTask {
-    ClearCheck,
-    AddCheck(FileId, Diagnostic, Vec<lsp_ext::CodeAction>),
-    SetNative(FileId, Vec<Diagnostic>),
 }
 impl DiagnosticCollection {
-    pub fn clear_check(&mut self) -> Vec<FileId> {
+    pub(crate) fn clear_check(&mut self) {
        Arc::make_mut(&mut self.check_fixes).clear();
-        self.check.drain().map(|(key, _value)| key).collect()
+        self.changes.extend(self.check.drain().map(|(key, _value)| key))
    }
-    pub fn add_check_diagnostic(
+    pub(crate) fn add_check_diagnostic(
        &mut self,
        file_id: FileId,
-        diagnostic: Diagnostic,
+        diagnostic: lsp_types::Diagnostic,
        fixes: Vec<lsp_ext::CodeAction>,
    ) {
        let diagnostics = self.check.entry(file_id).or_default();
@@ -61,34 +55,36 @@ impl DiagnosticCollection {
            .or_default()
            .extend(fixes.into_iter().map(|action| Fix { range: diagnostic.range, action }));
        diagnostics.push(diagnostic);
+        self.changes.insert(file_id);
    }
-    pub fn set_native_diagnostics(&mut self, file_id: FileId, diagnostics: Vec<Diagnostic>) {
+    pub(crate) fn set_native_diagnostics(
+        &mut self,
+        file_id: FileId,
+        diagnostics: Vec<lsp_types::Diagnostic>,
+    ) {
        self.native.insert(file_id, diagnostics);
+        self.changes.insert(file_id);
    }
-    pub fn diagnostics_for(&self, file_id: FileId) -> impl Iterator<Item = &Diagnostic> {
+    pub(crate) fn diagnostics_for(
+        &self,
+        file_id: FileId,
+    ) -> impl Iterator<Item = &lsp_types::Diagnostic> {
        let native = self.native.get(&file_id).into_iter().flatten();
        let check = self.check.get(&file_id).into_iter().flatten();
        native.chain(check)
    }
-    pub fn handle_task(&mut self, task: DiagnosticTask) -> Vec<FileId> {
+    pub(crate) fn take_changes(&mut self) -> Option<FxHashSet<FileId>> {
-        match task {
+        if self.changes.is_empty() {
-            DiagnosticTask::ClearCheck => self.clear_check(),
+            return None;
-            DiagnosticTask::AddCheck(file_id, diagnostic, fixes) => {
-                self.add_check_diagnostic(file_id, diagnostic, fixes);
-                vec![file_id]
-            }
-            DiagnosticTask::SetNative(file_id, diagnostics) => {
-                self.set_native_diagnostics(file_id, diagnostics);
-                vec![file_id]
-            }
        }
+        Some(mem::take(&mut self.changes))
    }
 }
-fn are_diagnostics_equal(left: &Diagnostic, right: &Diagnostic) -> bool {
+fn are_diagnostics_equal(left: &lsp_types::Diagnostic, right: &lsp_types::Diagnostic) -> bool {
    left.source == right.source
        && left.severity == right.severity
        && left.range == right.range
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index f379f5ed0..3eed118a9 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -167,9 +167,9 @@ fn map_rust_child_diagnostic(
 #[derive(Debug)]
 pub(crate) struct MappedRustDiagnostic {
-    pub location: Location,
+    pub(crate) location: Location,
-    pub diagnostic: Diagnostic,
+    pub(crate) diagnostic: Diagnostic,
-    pub fixes: Vec<lsp_ext::CodeAction>,
+    pub(crate) fixes: Vec<lsp_ext::CodeAction>,
 }
 /// Converts a Rust root diagnostic to LSP form
diff --git a/crates/rust-analyzer/src/dispatch.rs b/crates/rust-analyzer/src/dispatch.rs
new file mode 100644
index 000000000..891fdb96d
--- /dev/null
+++ b/crates/rust-analyzer/src/dispatch.rs
@@ -0,0 +1,170 @@
+//! A visitor for downcasting arbitrary request (JSON) into a specific type.
+use std::panic;
+use serde::{de::DeserializeOwned, Serialize};
+use crate::{
+    global_state::{GlobalState, GlobalStateSnapshot},
+    lsp_utils::is_canceled,
+    main_loop::Task,
+    LspError, Result,
+};
+pub(crate) struct RequestDispatcher<'a> {
+    pub(crate) req: Option<lsp_server::Request>,
+    pub(crate) global_state: &'a mut GlobalState,
+}
+impl<'a> RequestDispatcher<'a> {
+    /// Dispatches the request onto the current thread
+    pub(crate) fn on_sync<R>(
+        &mut self,
+        f: fn(&mut GlobalState, R::Params) -> Result<R::Result>,
+    ) -> Result<&mut Self>
+    where
+        R: lsp_types::request::Request + 'static,
+        R::Params: DeserializeOwned + panic::UnwindSafe + 'static,
+        R::Result: Serialize + 'static,
+    {
+        let (id, params) = match self.parse::<R>() {
+            Some(it) => it,
+            None => {
+                return Ok(self);
+            }
+        };
+        let world = panic::AssertUnwindSafe(&mut *self.global_state);
+        let response = panic::catch_unwind(move || {
+            let result = f(world.0, params);
+            result_to_response::<R>(id, result)
+        })
+        .map_err(|_| format!("sync task {:?} panicked", R::METHOD))?;
+        self.global_state.respond(response);
+        Ok(self)
+    }
+    /// Dispatches the request onto thread pool
+    pub(crate) fn on<R>(
+        &mut self,
+        f: fn(GlobalStateSnapshot, R::Params) -> Result<R::Result>,
+    ) -> Result<&mut Self>
+    where
+        R: lsp_types::request::Request + 'static,
+        R::Params: DeserializeOwned + Send + 'static,
+        R::Result: Serialize + 'static,
+    {
+        let (id, params) = match self.parse::<R>() {
+            Some(it) => it,
+            None => {
+                return Ok(self);
+            }
+        };
+        self.global_state.task_pool.handle.spawn({
+            let world = self.global_state.snapshot();
+            move || {
+                let result = f(world, params);
+                Task::Response(result_to_response::<R>(id, result))
+            }
+        });
+        Ok(self)
+    }
+    pub(crate) fn finish(&mut self) {
+        if let Some(req) = self.req.take() {
+            log::error!("unknown request: {:?}", req);
+            let response = lsp_server::Response::new_err(
+                req.id,
+                lsp_server::ErrorCode::MethodNotFound as i32,
+                "unknown request".to_string(),
+            );
+            self.global_state.respond(response)
+        }
+    }
+    fn parse<R>(&mut self) -> Option<(lsp_server::RequestId, R::Params)>
+    where
+        R: lsp_types::request::Request + 'static,
+        R::Params: DeserializeOwned + 'static,
+    {
+        let req = self.req.take()?;
+        let (id, params) = match req.extract::<R::Params>(R::METHOD) {
+            Ok(it) => it,
+            Err(req) => {
+                self.req = Some(req);
+                return None;
+            }
+        };
+        Some((id, params))
+    }
+}
+fn result_to_response<R>(
+    id: lsp_server::RequestId,
+    result: Result<R::Result>,
+) -> lsp_server::Response
+where
+    R: lsp_types::request::Request + 'static,
+    R::Params: DeserializeOwned + 'static,
+    R::Result: Serialize + 'static,
+{
+    match result {
+        Ok(resp) => lsp_server::Response::new_ok(id, &resp),
+        Err(e) => match e.downcast::<LspError>() {
+            Ok(lsp_error) => lsp_server::Response::new_err(id, lsp_error.code, lsp_error.message),
+            Err(e) => {
+                if is_canceled(&*e) {
+                    lsp_server::Response::new_err(
+                        id,
+                        lsp_server::ErrorCode::ContentModified as i32,
+                        "content modified".to_string(),
+                    )
+                } else {
+                    lsp_server::Response::new_err(
+                        id,
+                        lsp_server::ErrorCode::InternalError as i32,
+                        e.to_string(),
+                    )
+                }
+            }
+        },
+    }
+}
+pub(crate) struct NotificationDispatcher<'a> {
+    pub(crate) not: Option<lsp_server::Notification>,
+    pub(crate) global_state: &'a mut GlobalState,
+}
+impl<'a> NotificationDispatcher<'a> {
+    pub(crate) fn on<N>(
+        &mut self,
+        f: fn(&mut GlobalState, N::Params) -> Result<()>,
+    ) -> Result<&mut Self>
+    where
+        N: lsp_types::notification::Notification + 'static,
+        N::Params: DeserializeOwned + Send + 'static,
+    {
+        let not = match self.not.take() {
+            Some(it) => it,
+            None => return Ok(self),
+        };
+        let params = match not.extract::<N::Params>(N::METHOD) {
+            Ok(it) => it,
+            Err(not) => {
+                self.not = Some(not);
+                return Ok(self);
+            }
+        };
+        f(self.global_state, params)?;
+        Ok(self)
+    }
+    pub(crate) fn finish(&mut self) {
+        if let Some(not) = &self.not {
+            if !not.method.starts_with("$/") {
+                log::error!("unhandled notification: {:?}", not);
+            }
+        }
+    }
+}
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 446207e9e..b8aa1e5b5 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -3,49 +3,29 @@
 //!
 //! Each tick provides an immutable snapshot of the state as `WorldSnapshot`.
-use std::{convert::TryFrom, sync::Arc};
+use std::{sync::Arc, time::Instant};
-use crossbeam_channel::{unbounded, Receiver};
+use crossbeam_channel::{unbounded, Receiver, Sender};
-use flycheck::{FlycheckConfig, FlycheckHandle};
+use flycheck::FlycheckHandle;
 use lsp_types::Url;
 use parking_lot::RwLock;
-use ra_db::{CrateId, SourceRoot, VfsPath};
+use ra_db::{CrateId, VfsPath};
-use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId};
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FileId};
 use ra_project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
-use stdx::format_to;
+use rustc_hash::{FxHashMap, FxHashSet};
-use vfs::{file_set::FileSetConfig, loader::Handle, AbsPath, AbsPathBuf};
 use crate::{
-    config::{Config, FilesWatcher},
+    config::Config,
    diagnostics::{CheckFixes, DiagnosticCollection},
    from_proto,
    line_endings::LineEndings,
-    main_loop::ReqQueue,
+    main_loop::Task,
+    reload::SourceRootConfig,
    request_metrics::{LatestRequests, RequestMetrics},
+    thread_pool::TaskPool,
    to_proto::url_from_abs_path,
    Result,
 };
-use rustc_hash::{FxHashMap, FxHashSet};
-fn create_flycheck(
-    workspaces: &[ProjectWorkspace],
-    config: &FlycheckConfig,
-) -> Option<(FlycheckHandle, Receiver<flycheck::Message>)> {
-    // FIXME: Figure out the multi-workspace situation
-    workspaces.iter().find_map(move |w| match w {
-        ProjectWorkspace::Cargo { cargo, .. } => {
-            let (sender, receiver) = unbounded();
-            let sender = Box::new(move |msg| sender.send(msg).unwrap());
-            let cargo_project_root = cargo.workspace_root().to_path_buf();
-            let flycheck = FlycheckHandle::spawn(sender, config.clone(), cargo_project_root.into());
-            Some((flycheck, receiver))
-        }
-        ProjectWorkspace::Json { .. } => {
-            log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
-            None
-        }
-    })
-}
 #[derive(Eq, PartialEq)]
 pub(crate) enum Status {
@@ -59,26 +39,38 @@ impl Default for Status {
    }
 }
+// Enforces drop order
+pub(crate) struct Handle<H, C> {
+    pub(crate) handle: H,
+    pub(crate) receiver: C,
+}
+pub(crate) type ReqHandler = fn(&mut GlobalState, lsp_server::Response);
+pub(crate) type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;
 /// `GlobalState` is the primary mutable state of the language server
 ///
 /// The most interesting components are `vfs`, which stores a consistent
 /// snapshot of the file systems, and `analysis_host`, which stores our
 /// incremental salsa database.
+///
+/// Note that this struct has more than on impl in various modules!
 pub(crate) struct GlobalState {
+    sender: Sender<lsp_server::Message>,
+    req_queue: ReqQueue,
+    pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
+    pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
+    pub(crate) flycheck: Option<Handle<FlycheckHandle, Receiver<flycheck::Message>>>,
    pub(crate) config: Config,
    pub(crate) analysis_host: AnalysisHost,
-    pub(crate) loader: Box<dyn vfs::loader::Handle>,
-    pub(crate) task_receiver: Receiver<vfs::loader::Message>,
-    pub(crate) flycheck: Option<(FlycheckHandle, Receiver<flycheck::Message>)>,
    pub(crate) diagnostics: DiagnosticCollection,
    pub(crate) mem_docs: FxHashSet<VfsPath>,
    pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
    pub(crate) status: Status,
-    pub(crate) req_queue: ReqQueue,
+    pub(crate) source_root_config: SourceRootConfig,
+    pub(crate) proc_macro_client: ProcMacroClient,
+    pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
    latest_requests: Arc<RwLock<LatestRequests>>,
-    source_root_config: SourceRootConfig,
-    _proc_macro_client: ProcMacroClient,
-    workspaces: Arc<Vec<ProjectWorkspace>>,
 }
 /// An immutable snapshot of the world's state at a point in time.
@@ -88,99 +80,43 @@ pub(crate) struct GlobalStateSnapshot {
    pub(crate) check_fixes: CheckFixes,
    pub(crate) latest_requests: Arc<RwLock<LatestRequests>>,
    vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
-    workspaces: Arc<Vec<ProjectWorkspace>>,
+    pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
 }
 impl GlobalState {
-    pub(crate) fn new(
+    pub(crate) fn new(sender: Sender<lsp_server::Message>, config: Config) -> GlobalState {
-        workspaces: Vec<ProjectWorkspace>,
+        let loader = {
-        lru_capacity: Option<usize>,
+            let (sender, receiver) = unbounded::<vfs::loader::Message>();
-        config: Config,
+            let handle: vfs_notify::NotifyHandle =
-        req_queue: ReqQueue,
+                vfs::loader::Handle::spawn(Box::new(move |msg| sender.send(msg).unwrap()));
-    ) -> GlobalState {
+            let handle = Box::new(handle) as Box<dyn vfs::loader::Handle>;
-        let mut change = AnalysisChange::new();
+            Handle { handle, receiver }
-        let project_folders = ProjectFolders::new(&workspaces);
-        let (task_sender, task_receiver) = unbounded::<vfs::loader::Message>();
-        let mut vfs = vfs::Vfs::default();
-        let proc_macro_client = match &config.proc_macro_srv {
-            None => ProcMacroClient::dummy(),
-            Some((path, args)) => match ProcMacroClient::extern_process(path.into(), args) {
-                Ok(it) => it,
-                Err(err) => {
-                    log::error!(
-                        "Failed to run ra_proc_macro_srv from path {}, error: {:?}",
-                        path.display(),
-                        err
-                    );
-                    ProcMacroClient::dummy()
-                }
-            },
        };
-        let mut loader = {
+        let task_pool = {
-            let loader = vfs_notify::NotifyHandle::spawn(Box::new(move |msg| {
+            let (sender, receiver) = unbounded();
-                task_sender.send(msg).unwrap()
+            let handle = TaskPool::new(sender);
-            }));
+            Handle { handle, receiver }
-            Box::new(loader)
-        };
-        let watch = match config.files.watcher {
-            FilesWatcher::Client => vec![],
-            FilesWatcher::Notify => project_folders.watch,
-        };
-        loader.set_config(vfs::loader::Config { load: project_folders.load, watch });
-        // Create crate graph from all the workspaces
-        let mut crate_graph = CrateGraph::default();
-        let mut load = |path: &AbsPath| {
-            let contents = loader.load_sync(path);
-            let path = vfs::VfsPath::from(path.to_path_buf());
-            vfs.set_file_contents(path.clone(), contents);
-            vfs.file_id(&path)
        };
-        for ws in workspaces.iter() {
-            crate_graph.extend(ws.to_crate_graph(
-                config.cargo.target.as_deref(),
-                &proc_macro_client,
-                &mut load,
-            ));
-        }
-        change.set_crate_graph(crate_graph);
-        let flycheck = config.check.as_ref().and_then(|c| create_flycheck(&workspaces, c));
+        let analysis_host = AnalysisHost::new(config.lru_capacity);
+        GlobalState {
-        let mut analysis_host = AnalysisHost::new(lru_capacity);
+            sender,
-        analysis_host.apply_change(change);
+            req_queue: ReqQueue::default(),
-        let mut res = GlobalState {
+            task_pool,
+            loader,
+            flycheck: None,
            config,
            analysis_host,
-            loader,
-            task_receiver,
-            flycheck,
            diagnostics: Default::default(),
            mem_docs: FxHashSet::default(),
-            vfs: Arc::new(RwLock::new((vfs, FxHashMap::default()))),
+            vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
            status: Status::default(),
-            req_queue,
+            source_root_config: SourceRootConfig::default(),
+            proc_macro_client: ProcMacroClient::dummy(),
+            workspaces: Arc::new(Vec::new()),
            latest_requests: Default::default(),
-            source_root_config: project_folders.source_root_config,
-            _proc_macro_client: proc_macro_client,
-            workspaces: Arc::new(workspaces),
-        };
-        res.process_changes();
-        res
-    }
-    pub(crate) fn update_configuration(&mut self, config: Config) {
-        self.analysis_host.update_lru_capacity(config.lru_capacity);
-        if config.check != self.config.check {
-            self.flycheck =
-                config.check.as_ref().and_then(|it| create_flycheck(&self.workspaces, it));
        }
-        self.config = config;
    }
    pub(crate) fn process_changes(&mut self) -> bool {
@@ -232,26 +168,66 @@ impl GlobalState {
        }
    }
-    pub(crate) fn maybe_collect_garbage(&mut self) {
+    pub(crate) fn send_request<R: lsp_types::request::Request>(
-        self.analysis_host.maybe_collect_garbage()
+        &mut self,
+        params: R::Params,
+        handler: ReqHandler,
+    ) {
+        let request = self.req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
+        self.send(request.into());
+    }
+    pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
+        let handler = self.req_queue.outgoing.complete(response.id.clone());
+        handler(self, response)
+    }
+    pub(crate) fn send_notification<N: lsp_types::notification::Notification>(
+        &mut self,
+        params: N::Params,
+    ) {
+        let not = lsp_server::Notification::new(N::METHOD.to_string(), params);
+        self.send(not.into());
+    }
+    pub(crate) fn register_request(
+        &mut self,
+        request: &lsp_server::Request,
+        request_received: Instant,
+    ) {
+        self.req_queue
+            .incoming
+            .register(request.id.clone(), (request.method.clone(), request_received));
+    }
+    pub(crate) fn respond(&mut self, response: lsp_server::Response) {
+        if let Some((method, start)) = self.req_queue.incoming.complete(response.id.clone()) {
+            let duration = start.elapsed();
+            log::info!("handled req#{} in {:?}", response.id, duration);
+            let metrics =
+                RequestMetrics { id: response.id.clone(), method: method.to_string(), duration };
+            self.latest_requests.write().record(metrics);
+            self.send(response.into());
+        }
+    }
+    pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
+        if let Some(response) = self.req_queue.incoming.cancel(request_id) {
+            self.send(response.into());
+        }
    }
-    pub(crate) fn collect_garbage(&mut self) {
+    fn send(&mut self, message: lsp_server::Message) {
-        self.analysis_host.collect_garbage()
+        self.sender.send(message).unwrap()
    }
+}
-    pub(crate) fn complete_request(&mut self, request: RequestMetrics) {
+impl Drop for GlobalState {
-        self.latest_requests.write().record(request)
+    fn drop(&mut self) {
+        self.analysis_host.request_cancellation()
    }
 }
 impl GlobalStateSnapshot {
    pub(crate) fn url_to_file_id(&self, url: &Url) -> Result<FileId> {
-        let path = from_proto::abs_path(url)?;
+        url_to_file_id(&self.vfs.read().0, url)
-        let path = path.into();
-        let res =
-            self.vfs.read().0.file_id(&path).ok_or_else(|| format!("file not found: {}", path))?;
-        Ok(res)
    }
    pub(crate) fn file_id_to_url(&self, id: FileId) -> Url {
@@ -265,7 +241,7 @@ impl GlobalStateSnapshot {
    pub(crate) fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
        let mut base = self.vfs.read().0.file_path(file_id);
        base.pop();
-        let path = base.join(path);
+        let path = base.join(path).unwrap();
        let path = path.as_path().unwrap();
        url_from_abs_path(&path)
    }
@@ -284,26 +260,6 @@ impl GlobalStateSnapshot {
            ProjectWorkspace::Json { .. } => None,
        })
    }
-    pub(crate) fn status(&self) -> String {
-        let mut buf = String::new();
-        if self.workspaces.is_empty() {
-            buf.push_str("no workspaces\n")
-        } else {
-            buf.push_str("workspaces:\n");
-            for w in self.workspaces.iter() {
-                format_to!(buf, "{} packages loaded\n", w.n_packages());
-            }
-        }
-        buf.push_str("\nanalysis:\n");
-        buf.push_str(
-            &self
-                .analysis
-                .status()
-                .unwrap_or_else(|_| "Analysis retrieval was cancelled".to_owned()),
-        );
-        buf
-    }
 }
 pub(crate) fn file_id_to_url(vfs: &vfs::Vfs, id: FileId) -> Url {
@@ -312,77 +268,8 @@ pub(crate) fn file_id_to_url(vfs: &vfs::Vfs, id: FileId) -> Url {
    url_from_abs_path(&path)
 }
-#[derive(Default)]
+pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> Result<FileId> {
-pub(crate) struct ProjectFolders {
+    let path = from_proto::vfs_path(url)?;
-    pub(crate) load: Vec<vfs::loader::Entry>,
+    let res = vfs.file_id(&path).ok_or_else(|| format!("file not found: {}", path))?;
-    pub(crate) watch: Vec<usize>,
+    Ok(res)
-    pub(crate) source_root_config: SourceRootConfig,
-}
-impl ProjectFolders {
-    pub(crate) fn new(workspaces: &[ProjectWorkspace]) -> ProjectFolders {
-        let mut res = ProjectFolders::default();
-        let mut fsc = FileSetConfig::builder();
-        let mut local_filesets = vec![];
-        for root in workspaces.iter().flat_map(|it| it.to_roots()) {
-            let path = root.path().to_owned();
-            let mut file_set_roots: Vec<VfsPath> = vec![];
-            let entry = if root.is_member() {
-                vfs::loader::Entry::local_cargo_package(path.to_path_buf())
-            } else {
-                vfs::loader::Entry::cargo_package_dependency(path.to_path_buf())
-            };
-            res.load.push(entry);
-            if root.is_member() {
-                res.watch.push(res.load.len() - 1);
-            }
-            if let Some(out_dir) = root.out_dir() {
-                let out_dir = AbsPathBuf::try_from(out_dir.to_path_buf()).unwrap();
-                res.load.push(vfs::loader::Entry::rs_files_recursively(out_dir.clone()));
-                if root.is_member() {
-                    res.watch.push(res.load.len() - 1);
-                }
-                file_set_roots.push(out_dir.into());
-            }
-            file_set_roots.push(path.to_path_buf().into());
-            if root.is_member() {
-                local_filesets.push(fsc.len());
-            }
-            fsc.add_file_set(file_set_roots)
-        }
-        let fsc = fsc.build();
-        res.source_root_config = SourceRootConfig { fsc, local_filesets };
-        res
-    }
-}
-#[derive(Default, Debug)]
-pub(crate) struct SourceRootConfig {
-    pub(crate) fsc: FileSetConfig,
-    pub(crate) local_filesets: Vec<usize>,
-}
-impl SourceRootConfig {
-    pub(crate) fn partition(&self, vfs: &vfs::Vfs) -> Vec<SourceRoot> {
-        self.fsc
-            .partition(vfs)
-            .into_iter()
-            .enumerate()
-            .map(|(idx, file_set)| {
-                let is_local = self.local_filesets.contains(&idx);
-                if is_local {
-                    SourceRoot::new_local(file_set)
-                } else {
-                    SourceRoot::new_library(file_set)
-                }
-            })
-            .collect()
-    }
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index b2ff9a157..38e3c3324 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -31,7 +31,6 @@ use stdx::{format_to, split_delim};
 use crate::{
    cargo_target_spec::CargoTargetSpec,
    config::RustfmtConfig,
-    diagnostics::DiagnosticTask,
    from_json, from_proto,
    global_state::GlobalStateSnapshot,
    lsp_ext::{self, InlayHint, InlayHintsParams},
@@ -40,7 +39,20 @@ use crate::{
 pub(crate) fn handle_analyzer_status(snap: GlobalStateSnapshot, _: ()) -> Result<String> {
    let _p = profile("handle_analyzer_status");
-    let mut buf = snap.status();
+    let mut buf = String::new();
+    if snap.workspaces.is_empty() {
+        buf.push_str("no workspaces\n")
+    } else {
+        buf.push_str("workspaces:\n");
+        for w in snap.workspaces.iter() {
+            format_to!(buf, "{} packages loaded\n", w.n_packages());
+        }
+    }
+    buf.push_str("\nanalysis:\n");
+    buf.push_str(
+        &snap.analysis.status().unwrap_or_else(|_| "Analysis retrieval was cancelled".to_owned()),
+    );
    format_to!(buf, "\n\nrequests:\n");
    let requests = snap.latest_requests.read();
    for (is_last, r) in requests.iter() {
@@ -638,7 +650,7 @@ pub(crate) fn handle_formatting(
    let mut rustfmt = match &snap.config.rustfmt {
        RustfmtConfig::Rustfmt { extra_args } => {
-            let mut cmd = process::Command::new("rustfmt");
+            let mut cmd = process::Command::new(ra_toolchain::rustfmt());
            cmd.args(extra_args);
            if let Some(&crate_id) = crate_ids.first() {
                // Assume all crates are in the same edition
@@ -950,7 +962,7 @@ pub(crate) fn handle_ssr(
 pub(crate) fn publish_diagnostics(
    snap: &GlobalStateSnapshot,
    file_id: FileId,
-) -> Result<DiagnosticTask> {
+) -> Result<Vec<Diagnostic>> {
    let _p = profile("publish_diagnostics");
    let line_index = snap.analysis.file_line_index(file_id)?;
    let diagnostics: Vec<Diagnostic> = snap
@@ -967,7 +979,7 @@ pub(crate) fn publish_diagnostics(
            tags: None,
        })
        .collect();
-    Ok(DiagnosticTask::SetNative(file_id, diagnostics))
+    Ok(diagnostics)
 }
 pub(crate) fn handle_inlay_hints(
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 794286672..407944d85 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -18,7 +18,9 @@ macro_rules! eprintln {
 }
 mod global_state;
+mod reload;
 mod main_loop;
+mod dispatch;
 mod handlers;
 mod caps;
 mod cargo_target_spec;
@@ -30,13 +32,14 @@ mod diagnostics;
 mod line_endings;
 mod request_metrics;
 mod lsp_utils;
+mod thread_pool;
 pub mod lsp_ext;
 pub mod config;
 use serde::de::DeserializeOwned;
 pub type Result<T, E = Box<dyn std::error::Error + Send + Sync>> = std::result::Result<T, E>;
-pub use crate::{caps::server_capabilities, lsp_utils::show_message, main_loop::main_loop};
+pub use crate::{caps::server_capabilities, main_loop::main_loop};
 use std::fmt;
 pub fn from_json<T: DeserializeOwned>(what: &'static str, json: serde_json::Value) -> Result<T> {
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 14adb8ae7..0bc3ff115 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -1,23 +1,11 @@
 //! Utilities for LSP-related boilerplate code.
 use std::{error::Error, ops::Range};
-use crate::from_proto;
+use lsp_server::Notification;
-use crossbeam_channel::Sender;
-use lsp_server::{Message, Notification};
 use ra_db::Canceled;
 use ra_ide::LineIndex;
-use serde::{de::DeserializeOwned, Serialize};
-pub fn show_message(
+use crate::{from_proto, global_state::GlobalState};
-    typ: lsp_types::MessageType,
-    message: impl Into<String>,
-    sender: &Sender<Message>,
-) {
-    let message = message.into();
-    let params = lsp_types::ShowMessageParams { typ, message };
-    let not = notification_new::<lsp_types::notification::ShowMessage>(params);
-    sender.send(not.into()).unwrap();
-}
 pub(crate) fn is_canceled(e: &(dyn Error + 'static)) -> bool {
    e.downcast_ref::<Canceled>().is_some()
@@ -29,20 +17,68 @@ pub(crate) fn notification_is<N: lsp_types::notification::Notification>(
    notification.method == N::METHOD
 }
-pub(crate) fn notification_cast<N>(notification: Notification) -> Result<N::Params, Notification>
+#[derive(Debug, Eq, PartialEq)]
-where
+pub(crate) enum Progress {
-    N: lsp_types::notification::Notification,
+    Begin,
-    N::Params: DeserializeOwned,
+    Report,
-{
+    End,
-    notification.extract(N::METHOD)
+}
+impl Progress {
+    pub(crate) fn percentage(done: usize, total: usize) -> f64 {
+        (done as f64 / total.max(1) as f64) * 100.0
+    }
 }
-pub(crate) fn notification_new<N>(params: N::Params) -> Notification
+impl GlobalState {
-where
+    pub(crate) fn show_message(&mut self, typ: lsp_types::MessageType, message: String) {
-    N: lsp_types::notification::Notification,
+        let message = message.into();
-    N::Params: Serialize,
+        self.send_notification::<lsp_types::notification::ShowMessage>(
-{
+            lsp_types::ShowMessageParams { typ, message },
-    Notification::new(N::METHOD.to_string(), params)
+        )
+    }
+    pub(crate) fn report_progress(
+        &mut self,
+        title: &str,
+        state: Progress,
+        message: Option<String>,
+        percentage: Option<f64>,
+    ) {
+        if !self.config.client_caps.work_done_progress {
+            return;
+        }
+        let token = lsp_types::ProgressToken::String(format!("rustAnalyzer/{}", title));
+        let work_done_progress = match state {
+            Progress::Begin => {
+                self.send_request::<lsp_types::request::WorkDoneProgressCreate>(
+                    lsp_types::WorkDoneProgressCreateParams { token: token.clone() },
+                    |_, _| (),
+                );
+                lsp_types::WorkDoneProgress::Begin(lsp_types::WorkDoneProgressBegin {
+                    title: title.into(),
+                    cancellable: None,
+                    message,
+                    percentage,
+                })
+            }
+            Progress::Report => {
+                lsp_types::WorkDoneProgress::Report(lsp_types::WorkDoneProgressReport {
+                    cancellable: None,
+                    message,
+                    percentage,
+                })
+            }
+            Progress::End => {
+                lsp_types::WorkDoneProgress::End(lsp_types::WorkDoneProgressEnd { message })
+            }
+        };
+        self.send_notification::<lsp_types::notification::Progress>(lsp_types::ProgressParams {
+            token,
+            value: lsp_types::ProgressParamsValue::WorkDone(work_done_progress),
+        });
+    }
 }
 pub(crate) fn apply_document_changes(
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index a7a7d2eb7..e5194fe41 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -2,32 +2,24 @@
 //! requests/replies and notifications back to the client.
 use std::{
    env, fmt, panic,
-    sync::Arc,
    time::{Duration, Instant},
 };
-use crossbeam_channel::{never, select, unbounded, RecvError, Sender};
+use crossbeam_channel::{never, select, Receiver};
-use lsp_server::{Connection, ErrorCode, Notification, Request, RequestId, Response};
+use lsp_server::{Connection, Notification, Request, Response};
-use lsp_types::{request::Request as _, NumberOrString};
+use lsp_types::notification::Notification as _;
 use ra_db::VfsPath;
 use ra_ide::{Canceled, FileId};
 use ra_prof::profile;
-use ra_project_model::{PackageRoot, ProjectWorkspace};
-use serde::{de::DeserializeOwned, Serialize};
-use threadpool::ThreadPool;
 use crate::{
-    config::{Config, FilesWatcher, LinkedProject},
+    config::Config,
-    diagnostics::DiagnosticTask,
+    dispatch::{NotificationDispatcher, RequestDispatcher},
    from_proto,
-    global_state::{file_id_to_url, GlobalState, GlobalStateSnapshot, Status},
+    global_state::{file_id_to_url, url_to_file_id, GlobalState, Status},
    handlers, lsp_ext,
-    lsp_utils::{
+    lsp_utils::{apply_document_changes, is_canceled, notification_is, Progress},
-        apply_document_changes, is_canceled, notification_cast, notification_is, notification_new,
+    Result,
-        show_message,
-    },
-    request_metrics::RequestMetrics,
-    LspError, Result,
 };
 pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
@@ -52,124 +44,7 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
        SetThreadPriority(thread, thread_priority_above_normal);
    }
-    let mut global_state = {
+    GlobalState::new(connection.sender.clone(), config).run(connection.receiver)
-        let workspaces = {
-            if config.linked_projects.is_empty() && config.notifications.cargo_toml_not_found {
-                show_message(
-                    lsp_types::MessageType::Error,
-                    "rust-analyzer failed to discover workspace".to_string(),
-                    &connection.sender,
-                );
-            };
-            config
-                .linked_projects
-                .iter()
-                .filter_map(|project| match project {
-                    LinkedProject::ProjectManifest(manifest) => {
-                        ra_project_model::ProjectWorkspace::load(
-                            manifest.clone(),
-                            &config.cargo,
-                            config.with_sysroot,
-                        )
-                        .map_err(|err| {
-                            log::error!("failed to load workspace: {:#}", err);
-                            show_message(
-                                lsp_types::MessageType::Error,
-                                format!("rust-analyzer failed to load workspace: {:#}", err),
-                                &connection.sender,
-                            );
-                        })
-                        .ok()
-                    }
-                    LinkedProject::InlineJsonProject(it) => {
-                        Some(ra_project_model::ProjectWorkspace::Json { project: it.clone() })
-                    }
-                })
-                .collect::<Vec<_>>()
-        };
-        let mut req_queue = ReqQueue::default();
-        if let FilesWatcher::Client = config.files.watcher {
-            let registration_options = lsp_types::DidChangeWatchedFilesRegistrationOptions {
-                watchers: workspaces
-                    .iter()
-                    .flat_map(ProjectWorkspace::to_roots)
-                    .filter(PackageRoot::is_member)
-                    .map(|root| format!("{}/**/*.rs", root.path().display()))
-                    .map(|glob_pattern| lsp_types::FileSystemWatcher { glob_pattern, kind: None })
-                    .collect(),
-            };
-            let registration = lsp_types::Registration {
-                id: "file-watcher".to_string(),
-                method: "workspace/didChangeWatchedFiles".to_string(),
-                register_options: Some(serde_json::to_value(registration_options).unwrap()),
-            };
-            let params = lsp_types::RegistrationParams { registrations: vec![registration] };
-            let request = req_queue.outgoing.register(
-                lsp_types::request::RegisterCapability::METHOD.to_string(),
-                params,
-                DO_NOTHING,
-            );
-            connection.sender.send(request.into()).unwrap();
-        }
-        GlobalState::new(workspaces, config.lru_capacity, config, req_queue)
-    };
-    let pool = ThreadPool::default();
-    let (task_sender, task_receiver) = unbounded::<Task>();
-    log::info!("server initialized, serving requests");
-    {
-        let task_sender = task_sender;
-        loop {
-            log::trace!("selecting");
-            let event = select! {
-                recv(&connection.receiver) -> msg => match msg {
-                    Ok(msg) => Event::Lsp(msg),
-                    Err(RecvError) => return Err("client exited without shutdown".into()),
-                },
-                recv(task_receiver) -> task => Event::Task(task.unwrap()),
-                recv(global_state.task_receiver) -> task => match task {
-                    Ok(task) => Event::Vfs(task),
-                    Err(RecvError) => return Err("vfs died".into()),
-                },
-                recv(global_state.flycheck.as_ref().map_or(&never(), |it| &it.1)) -> task => match task {
-                    Ok(task) => Event::Flycheck(task),
-                    Err(RecvError) => return Err("check watcher died".into()),
-                },
-            };
-            if let Event::Lsp(lsp_server::Message::Request(req)) = &event {
-                if connection.handle_shutdown(&req)? {
-                    break;
-                };
-            }
-            assert!(!global_state.vfs.read().0.has_changes());
-            loop_turn(&pool, &task_sender, &connection, &mut global_state, event)?;
-            assert!(!global_state.vfs.read().0.has_changes());
-        }
-    }
-    global_state.analysis_host.request_cancellation();
-    log::info!("waiting for tasks to finish...");
-    task_receiver.into_iter().for_each(|task| on_task(task, &connection.sender, &mut global_state));
-    log::info!("...tasks have finished");
-    log::info!("joining threadpool...");
-    pool.join();
-    drop(pool);
-    log::info!("...threadpool has finished");
-    let vfs = Arc::try_unwrap(global_state.vfs).expect("all snapshots should be dead");
-    drop(vfs);
-    Ok(())
-}
-#[derive(Debug)]
-enum Task {
-    Respond(Response),
-    Diagnostic(DiagnosticTask),
 }
 enum Event {
@@ -179,6 +54,13 @@ enum Event {
    Flycheck(flycheck::Message),
 }
+#[derive(Debug)]
+pub(crate) enum Task {
+    Response(Response),
+    Diagnostics(Vec<(FileId, Vec<lsp_types::Diagnostic>)>),
+    Unit,
+}
 impl fmt::Debug for Event {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let debug_verbose_not = |not: &Notification, f: &mut fmt::Formatter| {
@@ -193,7 +75,7 @@ impl fmt::Debug for Event {
                    return debug_verbose_not(not, f);
                }
            }
-            Event::Task(Task::Respond(resp)) => {
+            Event::Task(Task::Response(resp)) => {
                return f
                    .debug_struct("Response")
                    .field("id", &resp.id)
@@ -211,616 +93,369 @@ impl fmt::Debug for Event {
    }
 }
-pub(crate) type ReqHandler = fn(&mut GlobalState, Response);
+impl GlobalState {
-pub(crate) type ReqQueue = lsp_server::ReqQueue<(&'static str, Instant), ReqHandler>;
+    fn next_event(&self, inbox: &Receiver<lsp_server::Message>) -> Option<Event> {
-const DO_NOTHING: ReqHandler = |_, _| ();
+        select! {
+            recv(inbox) -> msg =>
-fn loop_turn(
+                msg.ok().map(Event::Lsp),
-    pool: &ThreadPool,
-    task_sender: &Sender<Task>,
-    connection: &Connection,
-    global_state: &mut GlobalState,
-    event: Event,
-) -> Result<()> {
-    let loop_start = Instant::now();
-    // NOTE: don't count blocking select! call as a loop-turn time
-    let _p = profile("main_loop_inner/loop-turn");
-    log::info!("loop turn = {:?}", event);
-    let queue_count = pool.queued_count();
-    if queue_count > 0 {
-        log::info!("queued count = {}", queue_count);
-    }
-    let mut became_ready = false;
-    match event {
-        Event::Task(task) => {
-            on_task(task, &connection.sender, global_state);
-            global_state.maybe_collect_garbage();
-        }
-        Event::Vfs(task) => match task {
-            vfs::loader::Message::Loaded { files } => {
-                let vfs = &mut global_state.vfs.write().0;
-                for (path, contents) in files {
-                    let path = VfsPath::from(path);
-                    if !global_state.mem_docs.contains(&path) {
-                        vfs.set_file_contents(path, contents)
-                    }
-                }
-            }
-            vfs::loader::Message::Progress { n_total, n_done } => {
-                let state = if n_done == 0 {
-                    Progress::Begin
-                } else if n_done < n_total {
-                    Progress::Report
-                } else {
-                    assert_eq!(n_done, n_total);
-                    global_state.status = Status::Ready;
-                    became_ready = true;
-                    Progress::End
-                };
-                report_progress(
-                    global_state,
-                    &connection.sender,
-                    "roots scanned",
-                    state,
-                    Some(format!("{}/{}", n_done, n_total)),
-                    Some(percentage(n_done, n_total)),
-                )
-            }
-        },
-        Event::Flycheck(task) => {
-            on_check_task(task, global_state, task_sender, &connection.sender)?
-        }
-        Event::Lsp(msg) => match msg {
-            lsp_server::Message::Request(req) => {
-                on_request(global_state, pool, task_sender, &connection.sender, loop_start, req)?
-            }
-            lsp_server::Message::Notification(not) => {
-                on_notification(&connection.sender, global_state, not)?;
-            }
-            lsp_server::Message::Response(resp) => {
-                let handler = global_state.req_queue.outgoing.complete(resp.id.clone());
-                handler(global_state, resp)
-            }
-        },
-    };
-    let state_changed = global_state.process_changes();
-    if became_ready {
-        if let Some(flycheck) = &global_state.flycheck {
-            flycheck.0.update();
-        }
-    }
-    if global_state.status == Status::Ready && (state_changed || became_ready) {
+            recv(self.task_pool.receiver) -> task =>
-        let subscriptions = global_state
+                Some(Event::Task(task.unwrap())),
-            .mem_docs
-            .iter()
-            .map(|path| global_state.vfs.read().0.file_id(&path).unwrap())
-            .collect::<Vec<_>>();
-        update_file_notifications_on_threadpool(
+            recv(self.loader.receiver) -> task =>
-            pool,
+                Some(Event::Vfs(task.unwrap())),
-            global_state.snapshot(),
-            task_sender.clone(),
-            subscriptions.clone(),
-        );
-        pool.execute({
-            let subs = subscriptions;
-            let snap = global_state.snapshot();
-            move || snap.analysis.prime_caches(subs).unwrap_or_else(|_: Canceled| ())
-        });
-    }
-    let loop_duration = loop_start.elapsed();
+            recv(self.flycheck.as_ref().map_or(&never(), |it| &it.receiver)) -> task =>
-    if loop_duration > Duration::from_millis(100) {
+                Some(Event::Flycheck(task.unwrap())),
-        log::error!("overly long loop turn: {:?}", loop_duration);
-        if env::var("RA_PROFILE").is_ok() {
-            show_message(
-                lsp_types::MessageType::Error,
-                format!("overly long loop turn: {:?}", loop_duration),
-                &connection.sender,
-            );
        }
    }
-    Ok(())
+    fn run(mut self, inbox: Receiver<lsp_server::Message>) -> Result<()> {
-}
+        self.reload();
-fn on_task(task: Task, msg_sender: &Sender<lsp_server::Message>, global_state: &mut GlobalState) {
+        while let Some(event) = self.next_event(&inbox) {
-    match task {
+            if let Event::Lsp(lsp_server::Message::Notification(not)) = &event {
-        Task::Respond(response) => {
+                if not.method == lsp_types::notification::Exit::METHOD {
-            if let Some((method, start)) =
+                    return Ok(());
-                global_state.req_queue.incoming.complete(response.id.clone())
+                }
-            {
-                let duration = start.elapsed();
-                log::info!("handled req#{} in {:?}", response.id, duration);
-                global_state.complete_request(RequestMetrics {
-                    id: response.id.clone(),
-                    method: method.to_string(),
-                    duration,
-                });
-                msg_sender.send(response.into()).unwrap();
            }
+            self.handle_event(event)?
        }
-        Task::Diagnostic(task) => on_diagnostic_task(task, msg_sender, global_state),
+        Err("client exited without proper shutdown sequence")?
    }
-}
-fn on_request(
+    fn handle_event(&mut self, event: Event) -> Result<()> {
-    global_state: &mut GlobalState,
+        let loop_start = Instant::now();
-    pool: &ThreadPool,
+        // NOTE: don't count blocking select! call as a loop-turn time
-    task_sender: &Sender<Task>,
+        let _p = profile("GlobalState::handle_event");
-    msg_sender: &Sender<lsp_server::Message>,
-    request_received: Instant,
-    req: Request,
-) -> Result<()> {
-    let mut pool_dispatcher = PoolDispatcher {
-        req: Some(req),
-        pool,
-        global_state,
-        task_sender,
-        msg_sender,
-        request_received,
-    };
-    pool_dispatcher
-        .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
-        .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
-        .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
-        .on_sync::<lsp_types::request::SelectionRangeRequest>(|s, p| {
-            handlers::handle_selection_range(s.snapshot(), p)
-        })?
-        .on_sync::<lsp_ext::MatchingBrace>(|s, p| handlers::handle_matching_brace(s.snapshot(), p))?
-        .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)?
-        .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)?
-        .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)?
-        .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)?
-        .on::<lsp_ext::Runnables>(handlers::handle_runnables)?
-        .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
-        .on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)?
-        .on::<lsp_ext::ResolveCodeActionRequest>(handlers::handle_resolve_code_action)?
-        .on::<lsp_ext::HoverRequest>(handlers::handle_hover)?
-        .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
-        .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
-        .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
-        .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)?
-        .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)?
-        .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
-        .on::<lsp_types::request::Completion>(handlers::handle_completion)?
-        .on::<lsp_types::request::CodeLensRequest>(handlers::handle_code_lens)?
-        .on::<lsp_types::request::CodeLensResolve>(handlers::handle_code_lens_resolve)?
-        .on::<lsp_types::request::FoldingRangeRequest>(handlers::handle_folding_range)?
-        .on::<lsp_types::request::SignatureHelpRequest>(handlers::handle_signature_help)?
-        .on::<lsp_types::request::PrepareRenameRequest>(handlers::handle_prepare_rename)?
-        .on::<lsp_types::request::Rename>(handlers::handle_rename)?
-        .on::<lsp_types::request::References>(handlers::handle_references)?
-        .on::<lsp_types::request::Formatting>(handlers::handle_formatting)?
-        .on::<lsp_types::request::DocumentHighlightRequest>(handlers::handle_document_highlight)?
-        .on::<lsp_types::request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
-        .on::<lsp_types::request::CallHierarchyIncomingCalls>(
-            handlers::handle_call_hierarchy_incoming,
-        )?
-        .on::<lsp_types::request::CallHierarchyOutgoingCalls>(
-            handlers::handle_call_hierarchy_outgoing,
-        )?
-        .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
-        .on::<lsp_types::request::SemanticTokensRangeRequest>(
-            handlers::handle_semantic_tokens_range,
-        )?
-        .on::<lsp_ext::Ssr>(handlers::handle_ssr)?
-        .finish();
-    Ok(())
-}
-fn on_notification(
+        log::info!("handle_event({:?})", event);
-    msg_sender: &Sender<lsp_server::Message>,
+        let queue_count = self.task_pool.handle.len();
-    global_state: &mut GlobalState,
+        if queue_count > 0 {
-    not: Notification,
+            log::info!("queued count = {}", queue_count);
-) -> Result<()> {
-    let not = match notification_cast::<lsp_types::notification::Cancel>(not) {
-        Ok(params) => {
-            let id: RequestId = match params.id {
-                NumberOrString::Number(id) => id.into(),
-                NumberOrString::String(id) => id.into(),
-            };
-            if let Some(response) = global_state.req_queue.incoming.cancel(id) {
-                msg_sender.send(response.into()).unwrap()
-            }
-            return Ok(());
        }
-        Err(not) => not,
-    };
+        let mut became_ready = false;
-    let not = match notification_cast::<lsp_types::notification::DidOpenTextDocument>(not) {
+        match event {
-        Ok(params) => {
+            Event::Lsp(msg) => match msg {
-            if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                lsp_server::Message::Request(req) => self.on_request(loop_start, req)?,
-                if !global_state.mem_docs.insert(path.clone()) {
+                lsp_server::Message::Notification(not) => {
-                    log::error!("duplicate DidOpenTextDocument: {}", path)
+                    self.on_notification(not)?;
                }
-                global_state
+                lsp_server::Message::Response(resp) => self.complete_request(resp),
-                    .vfs
+            },
-                    .write()
+            Event::Task(task) => {
-                    .0
+                match task {
-                    .set_file_contents(path, Some(params.text_document.text.into_bytes()));
+                    Task::Response(response) => self.respond(response),
-            }
+                    Task::Diagnostics(diagnostics_per_file) => {
-            return Ok(());
+                        for (file_id, diagnostics) in diagnostics_per_file {
-        }
+                            self.diagnostics.set_native_diagnostics(file_id, diagnostics)
-        Err(not) => not,
+                        }
-    };
+                    }
-    let not = match notification_cast::<lsp_types::notification::DidChangeTextDocument>(not) {
+                    Task::Unit => (),
-        Ok(params) => {
+                }
-            if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                self.analysis_host.maybe_collect_garbage();
-                assert!(global_state.mem_docs.contains(&path));
-                let vfs = &mut global_state.vfs.write().0;
-                let file_id = vfs.file_id(&path).unwrap();
-                let mut text = String::from_utf8(vfs.file_contents(file_id).to_vec()).unwrap();
-                apply_document_changes(&mut text, params.content_changes);
-                vfs.set_file_contents(path, Some(text.into_bytes()))
            }
-            return Ok(());
+            Event::Vfs(task) => match task {
-        }
+                vfs::loader::Message::Loaded { files } => {
-        Err(not) => not,
+                    let vfs = &mut self.vfs.write().0;
-    };
+                    for (path, contents) in files {
-    let not = match notification_cast::<lsp_types::notification::DidCloseTextDocument>(not) {
+                        let path = VfsPath::from(path);
-        Ok(params) => {
+                        if !self.mem_docs.contains(&path) {
-            if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                            vfs.set_file_contents(path, contents)
-                if !global_state.mem_docs.remove(&path) {
+                        }
-                    log::error!("orphan DidCloseTextDocument: {}", path)
+                    }
                }
-                if let Some(path) = path.as_path() {
+                vfs::loader::Message::Progress { n_total, n_done } => {
-                    global_state.loader.invalidate(path.to_path_buf());
+                    let state = if n_done == 0 {
+                        Progress::Begin
+                    } else if n_done < n_total {
+                        Progress::Report
+                    } else {
+                        assert_eq!(n_done, n_total);
+                        self.status = Status::Ready;
+                        became_ready = true;
+                        Progress::End
+                    };
+                    self.report_progress(
+                        "roots scanned",
+                        state,
+                        Some(format!("{}/{}", n_done, n_total)),
+                        Some(Progress::percentage(n_done, n_total)),
+                    )
+                }
+            },
+            Event::Flycheck(task) => match task {
+                flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
+                    let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
+                        &self.config.diagnostics,
+                        &diagnostic,
+                        &workspace_root,
+                    );
+                    for diag in diagnostics {
+                        match url_to_file_id(&self.vfs.read().0, &diag.location.uri) {
+                            Ok(file_id) => self.diagnostics.add_check_diagnostic(
+                                file_id,
+                                diag.diagnostic,
+                                diag.fixes,
+                            ),
+                            Err(err) => {
+                                log::error!("File with cargo diagnostic not found in VFS: {}", err);
+                            }
+                        };
+                    }
                }
-            }
-            let params = lsp_types::PublishDiagnosticsParams {
-                uri: params.text_document.uri,
-                diagnostics: Vec::new(),
-                version: None,
-            };
-            let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
-            msg_sender.send(not.into()).unwrap();
-            return Ok(());
-        }
-        Err(not) => not,
-    };
-    let not = match notification_cast::<lsp_types::notification::DidSaveTextDocument>(not) {
-        Ok(_params) => {
-            if let Some(flycheck) = &global_state.flycheck {
-                flycheck.0.update();
-            }
-            return Ok(());
-        }
-        Err(not) => not,
-    };
-    let not = match notification_cast::<lsp_types::notification::DidChangeConfiguration>(not) {
-        Ok(_) => {
-            // As stated in https://github.com/microsoft/language-server-protocol/issues/676,
-            // this notification's parameters should be ignored and the actual config queried separately.
-            let request = global_state.req_queue.outgoing.register(
-                lsp_types::request::WorkspaceConfiguration::METHOD.to_string(),
-                lsp_types::ConfigurationParams {
-                    items: vec![lsp_types::ConfigurationItem {
-                        scope_uri: None,
-                        section: Some("rust-analyzer".to_string()),
-                    }],
-                },
-                |global_state, resp| {
-                    log::debug!("config update response: '{:?}", resp);
-                    let Response { error, result, .. } = resp;
-                    match (error, result) {
+                flycheck::Message::Progress(status) => {
-                        (Some(err), _) => {
+                    let (state, message) = match status {
-                            log::error!("failed to fetch the server settings: {:?}", err)
+                        flycheck::Progress::DidStart => {
+                            self.diagnostics.clear_check();
+                            (Progress::Begin, None)
                        }
-                        (None, Some(configs)) => {
+                        flycheck::Progress::DidCheckCrate(target) => {
-                            if let Some(new_config) = configs.get(0) {
+                            (Progress::Report, Some(target))
-                                let mut config = global_state.config.clone();
-                                config.update(&new_config);
-                                global_state.update_configuration(config);
-                            }
                        }
-                        (None, None) => {
+                        flycheck::Progress::DidFinish | flycheck::Progress::DidCancel => {
-                            log::error!("received empty server settings response from the client")
+                            (Progress::End, None)
                        }
-                    }
+                    };
-                },
-            );
-            msg_sender.send(request.into())?;
-            return Ok(());
+                    self.report_progress("cargo check", state, message, None);
-        }
-        Err(not) => not,
-    };
-    let not = match notification_cast::<lsp_types::notification::DidChangeWatchedFiles>(not) {
-        Ok(params) => {
-            for change in params.changes {
-                if let Ok(path) = from_proto::abs_path(&change.uri) {
-                    global_state.loader.invalidate(path)
                }
-            }
+            },
-            return Ok(());
        }
-        Err(not) => not,
-    };
-    if not.method.starts_with("$/") {
-        return Ok(());
-    }
-    log::error!("unhandled notification: {:?}", not);
-    Ok(())
-}
-fn on_check_task(
-    task: flycheck::Message,
-    global_state: &mut GlobalState,
-    task_sender: &Sender<Task>,
-    msg_sender: &Sender<lsp_server::Message>,
-) -> Result<()> {
-    match task {
-        flycheck::Message::ClearDiagnostics => {
-            task_sender.send(Task::Diagnostic(DiagnosticTask::ClearCheck))?;
-        }
-        flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
-            let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
-                &global_state.config.diagnostics,
-                &diagnostic,
-                &workspace_root,
-            );
-            for diag in diagnostics {
-                let path = from_proto::vfs_path(&diag.location.uri)?;
-                let file_id = match global_state.vfs.read().0.file_id(&path) {
-                    Some(file) => FileId(file.0),
-                    None => {
-                        log::error!("File with cargo diagnostic not found in VFS: {}", path);
-                        return Ok(());
-                    }
-                };
-                task_sender.send(Task::Diagnostic(DiagnosticTask::AddCheck(
+        let state_changed = self.process_changes();
-                    file_id,
+        if became_ready {
-                    diag.diagnostic,
+            if let Some(flycheck) = &self.flycheck {
-                    diag.fixes.into_iter().map(|it| it.into()).collect(),
+                flycheck.handle.update();
-                )))?;
            }
        }
-        flycheck::Message::Progress(status) => {
+        if self.status == Status::Ready && (state_changed || became_ready) {
-            let (state, message) = match status {
+            let subscriptions = self
-                flycheck::Progress::Being => (Progress::Begin, None),
+                .mem_docs
-                flycheck::Progress::DidCheckCrate(target) => (Progress::Report, Some(target)),
+                .iter()
-                flycheck::Progress::End => (Progress::End, None),
+                .map(|path| self.vfs.read().0.file_id(&path).unwrap())
-            };
+                .collect::<Vec<_>>();
-            report_progress(global_state, msg_sender, "cargo check", state, message, None);
-        }
-    };
-    Ok(())
-}
-fn on_diagnostic_task(
-    task: DiagnosticTask,
-    msg_sender: &Sender<lsp_server::Message>,
-    state: &mut GlobalState,
-) {
-    let subscriptions = state.diagnostics.handle_task(task);
-    for file_id in subscriptions {
-        let url = file_id_to_url(&state.vfs.read().0, file_id);
-        let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect();
-        let params = lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None };
-        let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
-        msg_sender.send(not.into()).unwrap();
-    }
-}
-#[derive(Eq, PartialEq)]
-enum Progress {
-    Begin,
-    Report,
-    End,
-}
-fn percentage(done: usize, total: usize) -> f64 {
-    (done as f64 / total.max(1) as f64) * 100.0
-}
-fn report_progress(
-    global_state: &mut GlobalState,
-    sender: &Sender<lsp_server::Message>,
-    title: &str,
-    state: Progress,
-    message: Option<String>,
-    percentage: Option<f64>,
-) {
-    if !global_state.config.client_caps.work_done_progress {
-        return;
-    }
-    let token = lsp_types::ProgressToken::String(format!("rustAnalyzer/{}", title));
-    let work_done_progress = match state {
-        Progress::Begin => {
-            let work_done_progress_create = global_state.req_queue.outgoing.register(
-                lsp_types::request::WorkDoneProgressCreate::METHOD.to_string(),
-                lsp_types::WorkDoneProgressCreateParams { token: token.clone() },
-                DO_NOTHING,
-            );
-            sender.send(work_done_progress_create.into()).unwrap();
-            lsp_types::WorkDoneProgress::Begin(lsp_types::WorkDoneProgressBegin {
+            self.update_file_notifications_on_threadpool(subscriptions);
-                title: title.into(),
-                cancellable: None,
-                message,
-                percentage,
-            })
        }
-        Progress::Report => {
-            lsp_types::WorkDoneProgress::Report(lsp_types::WorkDoneProgressReport {
-                cancellable: None,
-                message,
-                percentage,
-            })
-        }
-        Progress::End => {
-            lsp_types::WorkDoneProgress::End(lsp_types::WorkDoneProgressEnd { message })
-        }
-    };
-    let notification =
-        notification_new::<lsp_types::notification::Progress>(lsp_types::ProgressParams {
-            token,
-            value: lsp_types::ProgressParamsValue::WorkDone(work_done_progress),
-        });
-    sender.send(notification.into()).unwrap();
-}
-struct PoolDispatcher<'a> {
+        if let Some(diagnostic_changes) = self.diagnostics.take_changes() {
-    req: Option<Request>,
+            for file_id in diagnostic_changes {
-    pool: &'a ThreadPool,
+                let url = file_id_to_url(&self.vfs.read().0, file_id);
-    global_state: &'a mut GlobalState,
+                let diagnostics = self.diagnostics.diagnostics_for(file_id).cloned().collect();
-    msg_sender: &'a Sender<lsp_server::Message>,
+                self.send_notification::<lsp_types::notification::PublishDiagnostics>(
-    task_sender: &'a Sender<Task>,
+                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None },
-    request_received: Instant,
+                );
-}
-impl<'a> PoolDispatcher<'a> {
-    /// Dispatches the request onto the current thread
-    fn on_sync<R>(
-        &mut self,
-        f: fn(&mut GlobalState, R::Params) -> Result<R::Result>,
-    ) -> Result<&mut Self>
-    where
-        R: lsp_types::request::Request + 'static,
-        R::Params: DeserializeOwned + panic::UnwindSafe + 'static,
-        R::Result: Serialize + 'static,
-    {
-        let (id, params) = match self.parse::<R>() {
-            Some(it) => it,
-            None => {
-                return Ok(self);
-            }
-        };
-        let world = panic::AssertUnwindSafe(&mut *self.global_state);
-        let task = panic::catch_unwind(move || {
-            let result = f(world.0, params);
-            result_to_task::<R>(id, result)
-        })
-        .map_err(|_| format!("sync task {:?} panicked", R::METHOD))?;
-        on_task(task, self.msg_sender, self.global_state);
-        Ok(self)
-    }
-    /// Dispatches the request onto thread pool
-    fn on<R>(
-        &mut self,
-        f: fn(GlobalStateSnapshot, R::Params) -> Result<R::Result>,
-    ) -> Result<&mut Self>
-    where
-        R: lsp_types::request::Request + 'static,
-        R::Params: DeserializeOwned + Send + 'static,
-        R::Result: Serialize + 'static,
-    {
-        let (id, params) = match self.parse::<R>() {
-            Some(it) => it,
-            None => {
-                return Ok(self);
            }
-        };
+        }
-        self.pool.execute({
+        let loop_duration = loop_start.elapsed();
-            let world = self.global_state.snapshot();
+        if loop_duration > Duration::from_millis(100) {
-            let sender = self.task_sender.clone();
+            log::warn!("overly long loop turn: {:?}", loop_duration);
-            move || {
+            if env::var("RA_PROFILE").is_ok() {
-                let result = f(world, params);
+                self.show_message(
-                let task = result_to_task::<R>(id, result);
+                    lsp_types::MessageType::Error,
-                sender.send(task).unwrap();
+                    format!("overly long loop turn: {:?}", loop_duration),
+                )
            }
-        });
+        }
+        Ok(())
-        Ok(self)
    }
-    fn parse<R>(&mut self) -> Option<(RequestId, R::Params)>
+    fn on_request(&mut self, request_received: Instant, req: Request) -> Result<()> {
-    where
+        self.register_request(&req, request_received);
-        R: lsp_types::request::Request + 'static,
-        R::Params: DeserializeOwned + 'static,
+        RequestDispatcher { req: Some(req), global_state: self }
-    {
+            .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.analysis_host.collect_garbage()))?
-        let req = self.req.take()?;
+            .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
-        let (id, params) = match req.extract::<R::Params>(R::METHOD) {
+            .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
-            Ok(it) => it,
+            .on_sync::<lsp_types::request::Shutdown>(|_, ()| Ok(()))?
-            Err(req) => {
+            .on_sync::<lsp_types::request::SelectionRangeRequest>(|s, p| {
-                self.req = Some(req);
+                handlers::handle_selection_range(s.snapshot(), p)
-                return None;
+            })?
-            }
+            .on_sync::<lsp_ext::MatchingBrace>(|s, p| {
-        };
+                handlers::handle_matching_brace(s.snapshot(), p)
-        self.global_state
+            })?
-            .req_queue
+            .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)?
-            .incoming
+            .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)?
-            .register(id.clone(), (R::METHOD, self.request_received));
+            .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)?
-        Some((id, params))
+            .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)?
+            .on::<lsp_ext::Runnables>(handlers::handle_runnables)?
+            .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
+            .on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)?
+            .on::<lsp_ext::ResolveCodeActionRequest>(handlers::handle_resolve_code_action)?
+            .on::<lsp_ext::HoverRequest>(handlers::handle_hover)?
+            .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
+            .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
+            .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
+            .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)?
+            .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)?
+            .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
+            .on::<lsp_types::request::Completion>(handlers::handle_completion)?
+            .on::<lsp_types::request::CodeLensRequest>(handlers::handle_code_lens)?
+            .on::<lsp_types::request::CodeLensResolve>(handlers::handle_code_lens_resolve)?
+            .on::<lsp_types::request::FoldingRangeRequest>(handlers::handle_folding_range)?
+            .on::<lsp_types::request::SignatureHelpRequest>(handlers::handle_signature_help)?
+            .on::<lsp_types::request::PrepareRenameRequest>(handlers::handle_prepare_rename)?
+            .on::<lsp_types::request::Rename>(handlers::handle_rename)?
+            .on::<lsp_types::request::References>(handlers::handle_references)?
+            .on::<lsp_types::request::Formatting>(handlers::handle_formatting)?
+            .on::<lsp_types::request::DocumentHighlightRequest>(
+                handlers::handle_document_highlight,
+            )?
+            .on::<lsp_types::request::CallHierarchyPrepare>(
+                handlers::handle_call_hierarchy_prepare,
+            )?
+            .on::<lsp_types::request::CallHierarchyIncomingCalls>(
+                handlers::handle_call_hierarchy_incoming,
+            )?
+            .on::<lsp_types::request::CallHierarchyOutgoingCalls>(
+                handlers::handle_call_hierarchy_outgoing,
+            )?
+            .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+            .on::<lsp_types::request::SemanticTokensRangeRequest>(
+                handlers::handle_semantic_tokens_range,
+            )?
+            .on::<lsp_ext::Ssr>(handlers::handle_ssr)?
+            .finish();
+        Ok(())
    }
+    fn on_notification(&mut self, not: Notification) -> Result<()> {
-    fn finish(&mut self) {
+        NotificationDispatcher { not: Some(not), global_state: self }
-        match self.req.take() {
+            .on::<lsp_types::notification::Cancel>(|this, params| {
-            None => (),
+                let id: lsp_server::RequestId = match params.id {
-            Some(req) => {
+                    lsp_types::NumberOrString::Number(id) => id.into(),
-                log::error!("unknown request: {:?}", req);
+                    lsp_types::NumberOrString::String(id) => id.into(),
-                let resp = Response::new_err(
+                };
-                    req.id,
+                this.cancel(id);
-                    ErrorCode::MethodNotFound as i32,
+                Ok(())
-                    "unknown request".to_string(),
+            })?
+            .on::<lsp_types::notification::DidOpenTextDocument>(|this, params| {
+                if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                    if !this.mem_docs.insert(path.clone()) {
+                        log::error!("duplicate DidOpenTextDocument: {}", path)
+                    }
+                    this.vfs
+                        .write()
+                        .0
+                        .set_file_contents(path, Some(params.text_document.text.into_bytes()));
+                }
+                Ok(())
+            })?
+            .on::<lsp_types::notification::DidChangeTextDocument>(|this, params| {
+                if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                    assert!(this.mem_docs.contains(&path));
+                    let vfs = &mut this.vfs.write().0;
+                    let file_id = vfs.file_id(&path).unwrap();
+                    let mut text = String::from_utf8(vfs.file_contents(file_id).to_vec()).unwrap();
+                    apply_document_changes(&mut text, params.content_changes);
+                    vfs.set_file_contents(path, Some(text.into_bytes()))
+                }
+                Ok(())
+            })?
+            .on::<lsp_types::notification::DidCloseTextDocument>(|this, params| {
+                if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
+                    if !this.mem_docs.remove(&path) {
+                        log::error!("orphan DidCloseTextDocument: {}", path)
+                    }
+                    if let Some(path) = path.as_path() {
+                        this.loader.handle.invalidate(path.to_path_buf());
+                    }
+                }
+                this.send_notification::<lsp_types::notification::PublishDiagnostics>(
+                    lsp_types::PublishDiagnosticsParams {
+                        uri: params.text_document.uri,
+                        diagnostics: Vec::new(),
+                        version: None,
+                    },
                );
-                self.msg_sender.send(resp.into()).unwrap();
+                Ok(())
-            }
+            })?
-        }
+            .on::<lsp_types::notification::DidSaveTextDocument>(|this, _params| {
-    }
+                if let Some(flycheck) = &this.flycheck {
-}
+                    flycheck.handle.update();
-fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task
-where
-    R: lsp_types::request::Request + 'static,
-    R::Params: DeserializeOwned + 'static,
-    R::Result: Serialize + 'static,
-{
-    let response = match result {
-        Ok(resp) => Response::new_ok(id, &resp),
-        Err(e) => match e.downcast::<LspError>() {
-            Ok(lsp_error) => Response::new_err(id, lsp_error.code, lsp_error.message),
-            Err(e) => {
-                if is_canceled(&*e) {
-                    Response::new_err(
-                        id,
-                        ErrorCode::ContentModified as i32,
-                        "content modified".to_string(),
-                    )
-                } else {
-                    Response::new_err(id, ErrorCode::InternalError as i32, e.to_string())
                }
-            }
+                Ok(())
-        },
+            })?
-    };
+            .on::<lsp_types::notification::DidChangeConfiguration>(|this, _params| {
-    Task::Respond(response)
+                // 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.
+                this.send_request::<lsp_types::request::WorkspaceConfiguration>(
-fn update_file_notifications_on_threadpool(
+                    lsp_types::ConfigurationParams {
-    pool: &ThreadPool,
+                        items: vec![lsp_types::ConfigurationItem {
-    world: GlobalStateSnapshot,
+                            scope_uri: None,
-    task_sender: Sender<Task>,
+                            section: Some("rust-analyzer".to_string()),
-    subscriptions: Vec<FileId>,
+                        }],
-) {
+                    },
-    log::trace!("updating notifications for {:?}", subscriptions);
+                    |this, resp| {
-    if world.config.publish_diagnostics {
+                        log::debug!("config update response: '{:?}", resp);
-        pool.execute(move || {
+                        let Response { error, result, .. } = resp;
-            for file_id in subscriptions {
-                match handlers::publish_diagnostics(&world, file_id) {
+                        match (error, result) {
-                    Err(e) => {
+                            (Some(err), _) => {
-                        if !is_canceled(&*e) {
+                                log::error!("failed to fetch the server settings: {:?}", err)
-                            log::error!("failed to compute diagnostics: {:?}", e);
+                            }
+                            (None, Some(configs)) => {
+                                if let Some(new_config) = configs.get(0) {
+                                    let mut config = this.config.clone();
+                                    config.update(&new_config);
+                                    this.update_configuration(config);
+                                }
+                            }
+                            (None, None) => log::error!(
+                                "received empty server settings response from the client"
+                            ),
                        }
-                    }
+                    },
-                    Ok(task) => {
+                );
-                        task_sender.send(Task::Diagnostic(task)).unwrap();
+                return Ok(());
+            })?
+            .on::<lsp_types::notification::DidChangeWatchedFiles>(|this, params| {
+                for change in params.changes {
+                    if let Ok(path) = from_proto::abs_path(&change.uri) {
+                        this.loader.handle.invalidate(path);
                    }
                }
+                Ok(())
+            })?
+            .finish();
+        Ok(())
+    }
+    fn update_file_notifications_on_threadpool(&mut self, subscriptions: Vec<FileId>) {
+        log::trace!("updating notifications for {:?}", subscriptions);
+        if self.config.publish_diagnostics {
+            let snapshot = self.snapshot();
+            let subscriptions = subscriptions.clone();
+            self.task_pool.handle.spawn(move || {
+                let diagnostics = subscriptions
+                    .into_iter()
+                    .filter_map(|file_id| {
+                        handlers::publish_diagnostics(&snapshot, file_id)
+                            .map_err(|err| {
+                                if !is_canceled(&*err) {
+                                    log::error!("failed to compute diagnostics: {:?}", err);
+                                }
+                                ()
+                            })
+                            .ok()
+                            .map(|diags| (file_id, diags))
+                    })
+                    .collect::<Vec<_>>();
+                Task::Diagnostics(diagnostics)
+            })
+        }
+        self.task_pool.handle.spawn({
+            let subs = subscriptions;
+            let snap = self.snapshot();
+            move || {
+                snap.analysis.prime_caches(subs).unwrap_or_else(|_: Canceled| ());
+                Task::Unit
            }
-        })
+        });
    }
 }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
new file mode 100644
index 000000000..ec71f8b29
--- /dev/null
+++ b/crates/rust-analyzer/src/reload.rs
@@ -0,0 +1,243 @@
+//! Project loading & configuration updates
+use std::{mem, sync::Arc};
+use crossbeam_channel::unbounded;
+use flycheck::FlycheckHandle;
+use ra_db::{CrateGraph, SourceRoot, VfsPath};
+use ra_ide::AnalysisChange;
+use ra_project_model::{PackageRoot, ProcMacroClient, ProjectWorkspace};
+use vfs::{file_set::FileSetConfig, AbsPath};
+use crate::{
+    config::{Config, FilesWatcher, LinkedProject},
+    global_state::{GlobalState, Handle},
+};
+impl GlobalState {
+    pub(crate) fn update_configuration(&mut self, config: Config) {
+        let old_config = mem::replace(&mut self.config, config);
+        if self.config.lru_capacity != old_config.lru_capacity {
+            self.analysis_host.update_lru_capacity(old_config.lru_capacity);
+        }
+        if self.config.flycheck != old_config.flycheck {
+            self.reload_flycheck();
+        }
+    }
+    pub(crate) fn reload(&mut self) {
+        let workspaces = {
+            if self.config.linked_projects.is_empty()
+                && self.config.notifications.cargo_toml_not_found
+            {
+                self.show_message(
+                    lsp_types::MessageType::Error,
+                    "rust-analyzer failed to discover workspace".to_string(),
+                );
+            };
+            self.config
+                .linked_projects
+                .iter()
+                .map(|project| match project {
+                    LinkedProject::ProjectManifest(manifest) => {
+                        ra_project_model::ProjectWorkspace::load(
+                            manifest.clone(),
+                            &self.config.cargo,
+                            self.config.with_sysroot,
+                        )
+                    }
+                    LinkedProject::InlineJsonProject(it) => {
+                        Ok(ra_project_model::ProjectWorkspace::Json { project: it.clone() })
+                    }
+                })
+                .collect::<Vec<_>>()
+                .into_iter()
+                .filter_map(|res| {
+                    res.map_err(|err| {
+                        log::error!("failed to load workspace: {:#}", err);
+                        self.show_message(
+                            lsp_types::MessageType::Error,
+                            format!("rust-analyzer failed to load workspace: {:#}", err),
+                        );
+                    })
+                    .ok()
+                })
+                .collect::<Vec<_>>()
+        };
+        if let FilesWatcher::Client = self.config.files.watcher {
+            let registration_options = lsp_types::DidChangeWatchedFilesRegistrationOptions {
+                watchers: workspaces
+                    .iter()
+                    .flat_map(ProjectWorkspace::to_roots)
+                    .filter(PackageRoot::is_member)
+                    .map(|root| format!("{}/**/*.rs", root.path().display()))
+                    .map(|glob_pattern| lsp_types::FileSystemWatcher { glob_pattern, kind: None })
+                    .collect(),
+            };
+            let registration = lsp_types::Registration {
+                id: "file-watcher".to_string(),
+                method: "workspace/didChangeWatchedFiles".to_string(),
+                register_options: Some(serde_json::to_value(registration_options).unwrap()),
+            };
+            self.send_request::<lsp_types::request::RegisterCapability>(
+                lsp_types::RegistrationParams { registrations: vec![registration] },
+                |_, _| (),
+            );
+        }
+        let mut change = AnalysisChange::new();
+        let project_folders = ProjectFolders::new(&workspaces);
+        self.proc_macro_client = match &self.config.proc_macro_srv {
+            None => ProcMacroClient::dummy(),
+            Some((path, args)) => match ProcMacroClient::extern_process(path.into(), args) {
+                Ok(it) => it,
+                Err(err) => {
+                    log::error!(
+                        "Failed to run ra_proc_macro_srv from path {}, error: {:?}",
+                        path.display(),
+                        err
+                    );
+                    ProcMacroClient::dummy()
+                }
+            },
+        };
+        let watch = match self.config.files.watcher {
+            FilesWatcher::Client => vec![],
+            FilesWatcher::Notify => project_folders.watch,
+        };
+        self.loader.handle.set_config(vfs::loader::Config { load: project_folders.load, watch });
+        // Create crate graph from all the workspaces
+        let crate_graph = {
+            let mut crate_graph = CrateGraph::default();
+            let vfs = &mut self.vfs.write().0;
+            let loader = &mut self.loader;
+            let mut load = |path: &AbsPath| {
+                let contents = loader.handle.load_sync(path);
+                let path = vfs::VfsPath::from(path.to_path_buf());
+                vfs.set_file_contents(path.clone(), contents);
+                vfs.file_id(&path)
+            };
+            for ws in workspaces.iter() {
+                crate_graph.extend(ws.to_crate_graph(
+                    self.config.cargo.target.as_deref(),
+                    &self.proc_macro_client,
+                    &mut load,
+                ));
+            }
+            crate_graph
+        };
+        change.set_crate_graph(crate_graph);
+        self.source_root_config = project_folders.source_root_config;
+        self.workspaces = Arc::new(workspaces);
+        self.analysis_host.apply_change(change);
+        self.process_changes();
+        self.reload_flycheck();
+    }
+    fn reload_flycheck(&mut self) {
+        let config = match self.config.flycheck.clone() {
+            Some(it) => it,
+            None => {
+                self.flycheck = None;
+                return;
+            }
+        };
+        // FIXME: Figure out the multi-workspace situation
+        self.flycheck = self.workspaces.iter().find_map(move |w| match w {
+            ProjectWorkspace::Cargo { cargo, .. } => {
+                let (sender, receiver) = unbounded();
+                let sender = Box::new(move |msg| sender.send(msg).unwrap());
+                let cargo_project_root = cargo.workspace_root().to_path_buf();
+                let handle =
+                    FlycheckHandle::spawn(sender, config.clone(), cargo_project_root.into());
+                Some(Handle { handle, receiver })
+            }
+            ProjectWorkspace::Json { .. } => {
+                log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
+                None
+            }
+        })
+    }
+}
+#[derive(Default)]
+pub(crate) struct ProjectFolders {
+    pub(crate) load: Vec<vfs::loader::Entry>,
+    pub(crate) watch: Vec<usize>,
+    pub(crate) source_root_config: SourceRootConfig,
+}
+impl ProjectFolders {
+    pub(crate) fn new(workspaces: &[ProjectWorkspace]) -> ProjectFolders {
+        let mut res = ProjectFolders::default();
+        let mut fsc = FileSetConfig::builder();
+        let mut local_filesets = vec![];
+        for root in workspaces.iter().flat_map(|it| it.to_roots()) {
+            let path = root.path().to_owned();
+            let mut file_set_roots: Vec<VfsPath> = vec![];
+            let entry = if root.is_member() {
+                vfs::loader::Entry::local_cargo_package(path.to_path_buf())
+            } else {
+                vfs::loader::Entry::cargo_package_dependency(path.to_path_buf())
+            };
+            res.load.push(entry);
+            if root.is_member() {
+                res.watch.push(res.load.len() - 1);
+            }
+            if let Some(out_dir) = root.out_dir() {
+                let out_dir = out_dir.to_path_buf();
+                res.load.push(vfs::loader::Entry::rs_files_recursively(out_dir.clone()));
+                if root.is_member() {
+                    res.watch.push(res.load.len() - 1);
+                }
+                file_set_roots.push(out_dir.into());
+            }
+            file_set_roots.push(path.to_path_buf().into());
+            if root.is_member() {
+                local_filesets.push(fsc.len());
+            }
+            fsc.add_file_set(file_set_roots)
+        }
+        let fsc = fsc.build();
+        res.source_root_config = SourceRootConfig { fsc, local_filesets };
+        res
+    }
+}
+#[derive(Default, Debug)]
+pub(crate) struct SourceRootConfig {
+    pub(crate) fsc: FileSetConfig,
+    pub(crate) local_filesets: Vec<usize>,
+}
+impl SourceRootConfig {
+    pub(crate) fn partition(&self, vfs: &vfs::Vfs) -> Vec<SourceRoot> {
+        self.fsc
+            .partition(vfs)
+            .into_iter()
+            .enumerate()
+            .map(|(idx, file_set)| {
+                let is_local = self.local_filesets.contains(&idx);
+                if is_local {
+                    SourceRoot::new_local(file_set)
+                } else {
+                    SourceRoot::new_library(file_set)
+                }
+            })
+            .collect()
+    }
+}
diff --git a/crates/rust-analyzer/src/thread_pool.rs b/crates/rust-analyzer/src/thread_pool.rs
new file mode 100644
index 000000000..4fa502925
--- /dev/null
+++ b/crates/rust-analyzer/src/thread_pool.rs
@@ -0,0 +1,35 @@
+//! A thin wrapper around `ThreadPool` to make sure that we join all things
+//! properly.
+use crossbeam_channel::Sender;
+pub(crate) struct TaskPool<T> {
+    sender: Sender<T>,
+    inner: threadpool::ThreadPool,
+}
+impl<T> TaskPool<T> {
+    pub(crate) fn new(sender: Sender<T>) -> TaskPool<T> {
+        TaskPool { sender, inner: threadpool::ThreadPool::default() }
+    }
+    pub(crate) fn spawn<F>(&mut self, task: F)
+    where
+        F: FnOnce() -> T + Send + 'static,
+        T: Send + 'static,
+    {
+        self.inner.execute({
+            let sender = self.sender.clone();
+            move || sender.send(task()).unwrap()
+        })
+    }
+    pub(crate) fn len(&self) -> usize {
+        self.inner.queued_count()
+    }
+}
+impl<T> Drop for TaskPool<T> {
+    fn drop(&mut self) {
+        self.inner.join()
+    }
+}
diff --git a/crates/vfs-notify/src/lib.rs b/crates/vfs-notify/src/lib.rs
index 68fdb8cb0..25ba8d798 100644
--- a/crates/vfs-notify/src/lib.rs
+++ b/crates/vfs-notify/src/lib.rs
@@ -82,7 +82,12 @@ impl NotifyActor {
            watcher_receiver,
        }
    }
+    fn next_event(&self, receiver: &Receiver<Message>) -> Option<Event> {
+        select! {
+            recv(receiver) -> it => it.ok().map(Event::Message),
+            recv(&self.watcher_receiver) -> it => Some(Event::NotifyEvent(it.unwrap())),
+        }
+    }
    fn run(mut self, inbox: Receiver<Message>) {
        while let Some(event) = self.next_event(&inbox) {
            log::debug!("vfs-notify event: {:?}", event);
@@ -154,12 +159,6 @@ impl NotifyActor {
            }
        }
    }
-    fn next_event(&self, receiver: &Receiver<Message>) -> Option<Event> {
-        select! {
-            recv(receiver) -> it => it.ok().map(Event::Message),
-            recv(&self.watcher_receiver) -> it => Some(Event::NotifyEvent(it.unwrap())),
-        }
-    }
    fn load_entry(
        &mut self,
        entry: loader::Entry,
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 0173f7464..d0ddeafe7 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -18,7 +18,7 @@ impl FileSet {
    pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
        let mut base = self.paths[&anchor].clone();
        base.pop();
-        let path = base.join(path);
+        let path = base.join(path)?;
        let res = self.files.get(&path).copied();
        res
    }
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 940f91d0e..dc3031ada 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -22,15 +22,15 @@ impl VfsPath {
            VfsPathRepr::VirtualPath(_) => None,
        }
    }
-    pub fn join(&self, path: &str) -> VfsPath {
+    pub fn join(&self, path: &str) -> Option<VfsPath> {
        match &self.0 {
            VfsPathRepr::PathBuf(it) => {
                let res = it.join(path).normalize();
-                VfsPath(VfsPathRepr::PathBuf(res))
+                Some(VfsPath(VfsPathRepr::PathBuf(res)))
            }
            VfsPathRepr::VirtualPath(it) => {
-                let res = it.join(path);
+                let res = it.join(path)?;
-                VfsPath(VfsPathRepr::VirtualPath(res))
+                Some(VfsPath(VfsPathRepr::VirtualPath(res)))
            }
        }
    }
@@ -101,13 +101,15 @@ impl VirtualPath {
        self.0 = self.0[..pos].to_string();
        true
    }
-    fn join(&self, mut path: &str) -> VirtualPath {
+    fn join(&self, mut path: &str) -> Option<VirtualPath> {
        let mut res = self.clone();
        while path.starts_with("../") {
-            assert!(res.pop());
+            if !res.pop() {
+                return None;
+            }
            path = &path["../".len()..]
        }
        res.0 = format!("{}/{}", res.0, path);
-        res
+        Some(res)
    }
 }
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 76e1da6cf..11dc5261b 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -166,6 +166,17 @@ That said, adding an innocent-looking `pub use` is a very simple way to break en
 Note: if you enjoyed this abstract hand-waving about boundaries, you might appreciate
 https://www.tedinski.com/2018/02/06/system-boundaries.html
+## Minimal Tests
+Most tests in rust-analyzer start with a snippet of Rust code.
+This snippets should be minimal -- if you copy-paste a snippet of real code into the tests, make sure to remove everything which could be removed.
+There are many benefits to this:
+* less to read or to scroll past
+* easier to understand what exactly is tested
+* less stuff printed during printf-debugging
+* less time to run test
 ## Order of Imports
 We separate import groups with blank lines
diff --git a/editors/code/package.json b/editors/code/package.json
index 68484a370..f542a490a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -336,6 +336,14 @@
                    "default": null,
                    "description": "List of features to activate. Defaults to `rust-analyzer.cargo.features`."
                },
+                "rust-analyzer.cargoRunner": {
+                    "type": [
+                        "null",
+                        "string"
+                    ],
+                    "default": null,
+                    "description": "Custom cargo runner extension ID."
+                },
                "rust-analyzer.inlayHints.enable": {
                    "type": "boolean",
                    "default": true,
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 48a25495f..8c9d7802f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -394,7 +394,7 @@ export function run(ctx: Ctx): Cmd {
        item.detail = 'rerun';
        prevRunnable = item;
-        const task = createTask(item.runnable);
+        const task = await createTask(item.runnable, ctx.config);
        return await vscode.tasks.executeTask(task);
    };
 }
@@ -404,7 +404,7 @@ export function runSingle(ctx: Ctx): Cmd {
        const editor = ctx.activeRustEditor;
        if (!editor) return;
-        const task = createTask(runnable);
+        const task = await createTask(runnable, ctx.config);
        task.group = vscode.TaskGroup.Build;
        task.presentationOptions = {
            reveal: vscode.TaskRevealKind.Always,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 9591d4fe3..fc95a7de6 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -110,6 +110,10 @@ export class Config {
        };
    }
+    get cargoRunner() {
+        return this.get<string | undefined>("cargoRunner");
+    }
    get debug() {
        // "/rustc/<id>" used by suggestions only.
        const { ["/rustc/<id>"]: _, ...sourceFileMap } = this.get<Record<string, string>>("debug.sourceFileMap");
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index cdb63b46f..5ceab8b44 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -114,7 +114,7 @@ export async function activate(context: vscode.ExtensionContext) {
    ctx.registerCommand('applyActionGroup', commands.applyActionGroup);
    ctx.registerCommand('gotoLocation', commands.gotoLocation);
-    ctx.pushCleanup(activateTaskProvider(workspaceFolder));
+    ctx.pushCleanup(activateTaskProvider(workspaceFolder, ctx.config));
    activateInlayHints(ctx);
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index bb060cfe1..766b05112 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -1,10 +1,11 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import * as ra from './lsp_ext';
-import * as toolchain from "./toolchain";
+import * as tasks from './tasks';
 import { Ctx } from './ctx';
 import { makeDebugConfig } from './debug';
+import { Config } from './config';
 const quickPickButtons = [{ iconPath: new vscode.ThemeIcon("save"), tooltip: "Save as a launch.json configurtation." }];
@@ -95,52 +96,29 @@ export class RunnableQuickPick implements vscode.QuickPickItem {
    }
 }
-interface CargoTaskDefinition extends vscode.TaskDefinition {
+export async function createTask(runnable: ra.Runnable, config: Config): Promise<vscode.Task> {
-    type: 'cargo';
+    if (runnable.kind !== "cargo") {
-    label: string;
+        // rust-analyzer supports only one kind, "cargo"
-    command: string;
+        // do not use tasks.TASK_TYPE here, these are completely different meanings.
-    args: string[];
-    env?: { [key: string]: string };
-}
-export function createTask(runnable: ra.Runnable): vscode.Task {
-    const TASK_SOURCE = 'Rust';
-    let command;
+        throw `Unexpected runnable kind: ${runnable.kind}`;
-    switch (runnable.kind) {
-        case "cargo": command = toolchain.getPathForExecutable("cargo");
    }
    const args = [...runnable.args.cargoArgs]; // should be a copy!
    if (runnable.args.executableArgs.length > 0) {
        args.push('--', ...runnable.args.executableArgs);
    }
-    const definition: CargoTaskDefinition = {
+    const definition: tasks.CargoTaskDefinition = {
-        type: 'cargo',
+        type: tasks.TASK_TYPE,
-        label: runnable.label,
+        command: args[0], // run, test, etc...
-        command,
+        args: args.slice(1),
-        args,
+        cwd: runnable.args.workspaceRoot,
        env: Object.assign({}, process.env as { [key: string]: string }, { "RUST_BACKTRACE": "short" }),
    };
-    const execOption: vscode.ShellExecutionOptions = {
+    const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate()
-        cwd: runnable.args.workspaceRoot || '.',
+    const cargoTask = await tasks.buildCargoTask(target, definition, runnable.label, args, config.cargoRunner, true);
-        env: definition.env,
+    cargoTask.presentationOptions.clear = true;
-    };
-    const exec = new vscode.ShellExecution(
+    return cargoTask;
-        definition.command,
-        definition.args,
-        execOption,
-    );
-    const f = vscode.workspace.workspaceFolders![0];
-    const t = new vscode.Task(
-        definition,
-        f,
-        definition.label,
-        TASK_SOURCE,
-        exec,
-        ['$rustc'],
-    );
-    t.presentationOptions.clear = true;
-    return t;
 }
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index 9748824df..14abbd5b7 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -1,11 +1,14 @@
 import * as vscode from 'vscode';
 import * as toolchain from "./toolchain";
+import { Config } from './config';
+import { log } from './util';
 // This ends up as the `type` key in tasks.json. RLS also uses `cargo` and
 // our configuration should be compatible with it so use the same key.
-const TASK_TYPE = 'cargo';
+export const TASK_TYPE = 'cargo';
+export const TASK_SOURCE = 'rust';
-interface CargoTaskDefinition extends vscode.TaskDefinition {
+export interface CargoTaskDefinition extends vscode.TaskDefinition {
    command?: string;
    args?: string[];
    cwd?: string;
@@ -14,73 +17,101 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
 class CargoTaskProvider implements vscode.TaskProvider {
    private readonly target: vscode.WorkspaceFolder;
+    private readonly config: Config;
-    constructor(target: vscode.WorkspaceFolder) {
+    constructor(target: vscode.WorkspaceFolder, config: Config) {
        this.target = target;
+        this.config = config;
    }
-    provideTasks(): vscode.Task[] {
+    async provideTasks(): Promise<vscode.Task[]> {
        // Detect Rust tasks. Currently we do not do any actual detection
        // of tasks (e.g. aliases in .cargo/config) and just return a fixed
        // set of tasks that always exist. These tasks cannot be removed in
        // tasks.json - only tweaked.
-        const cargoPath = toolchain.cargoPath();
+        const defs = [
-        return [
            { command: 'build', group: vscode.TaskGroup.Build },
            { command: 'check', group: vscode.TaskGroup.Build },
            { command: 'test', group: vscode.TaskGroup.Test },
            { command: 'clean', group: vscode.TaskGroup.Clean },
            { command: 'run', group: undefined },
-        ]
+        ];
-            .map(({ command, group }) => {
-                const vscodeTask = new vscode.Task(
+        const tasks: vscode.Task[] = [];
-                    // The contents of this object end up in the tasks.json entries.
+        for (const def of defs) {
-                    {
+            const vscodeTask = await buildCargoTask(this.target, { type: TASK_TYPE, command: def.command }, `cargo ${def.command}`, [def.command], this.config.cargoRunner);
-                        type: TASK_TYPE,
+            vscodeTask.group = def.group;
-                        command,
+            tasks.push(vscodeTask);
-                    },
+        }
-                    // The scope of the task - workspace or specific folder (global
-                    // is not supported).
+        return tasks;
-                    this.target,
-                    // The task name, and task source. These are shown in the UI as
-                    // `${source}: ${name}`, e.g. `rust: cargo build`.
-                    `cargo ${command}`,
-                    'rust',
-                    // What to do when this command is executed.
-                    new vscode.ShellExecution(cargoPath, [command]),
-                    // Problem matchers.
-                    ['$rustc'],
-                );
-                vscodeTask.group = group;
-                return vscodeTask;
-            });
    }
-    resolveTask(task: vscode.Task): vscode.Task | undefined {
+    async resolveTask(task: vscode.Task): Promise<vscode.Task | undefined> {
        // VSCode calls this for every cargo task in the user's tasks.json,
        // we need to inform VSCode how to execute that command by creating
        // a ShellExecution for it.
        const definition = task.definition as CargoTaskDefinition;
-        if (definition.type === 'cargo' && definition.command) {
+        if (definition.type === TASK_TYPE && definition.command) {
            const args = [definition.command].concat(definition.args ?? []);
-            return new vscode.Task(
+            return await buildCargoTask(this.target, definition, task.name, args, this.config.cargoRunner);
-                definition,
-                task.name,
-                'rust',
-                new vscode.ShellExecution('cargo', args, definition),
-            );
        }
        return undefined;
    }
 }
-export function activateTaskProvider(target: vscode.WorkspaceFolder): vscode.Disposable {
+export async function buildCargoTask(
-    const provider = new CargoTaskProvider(target);
+    target: vscode.WorkspaceFolder,
+    definition: CargoTaskDefinition,
+    name: string,
+    args: string[],
+    customRunner?: string,
+    throwOnError: boolean = false
+): Promise<vscode.Task> {
+    let exec: vscode.ShellExecution | undefined = undefined;
+    if (customRunner) {
+        const runnerCommand = `${customRunner}.buildShellExecution`;
+        try {
+            const runnerArgs = { kind: TASK_TYPE, args, cwd: definition.cwd, env: definition.env };
+            const customExec = await vscode.commands.executeCommand(runnerCommand, runnerArgs);
+            if (customExec) {
+                if (customExec instanceof vscode.ShellExecution) {
+                    exec = customExec;
+                } else {
+                    log.debug("Invalid cargo ShellExecution", customExec);
+                    throw "Invalid cargo ShellExecution.";
+                }
+            }
+            // fallback to default processing
+        } catch (e) {
+            if (throwOnError) throw `Cargo runner '${customRunner}' failed! ${e}`;
+            // fallback to default processing
+        }
+    }
+    if (!exec) {
+        exec = new vscode.ShellExecution(toolchain.cargoPath(), args, definition);
+    }
+    return new vscode.Task(
+        definition,
+        target,
+        name,
+        TASK_SOURCE,
+        exec,
+        ['$rustc']
+    );
+}
+export function activateTaskProvider(target: vscode.WorkspaceFolder, config: Config): vscode.Disposable {
+    const provider = new CargoTaskProvider(target, config);
    return vscode.tasks.registerTaskProvider(TASK_TYPE, provider);
 }