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
-                }