37 files changed, 869 insertions, 497 deletions
diff --git a/Cargo.lock b/Cargo.lock
index f22366a36..fe71b9971 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1458,6 +1458,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 4dcab7a61..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,7 +115,7 @@ 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);
@@ -128,65 +125,48 @@ impl FlycheckActor {
        }
    }
    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();
-            }
        }
+        // If we rerun the thread, we need to discard the previous check results first
+        self.cancel_check_process();
    }
-    fn should_recheck(&mut self) -> bool {
+    fn cancel_check_process(&mut self) {
-        if let Some(_last_update_req) = &self.last_update_req {
+        if self.check_process.take().is_some() {
-            // We currently only request an update on save, as we need up to
+            self.send(Message::Progress(Progress::DidCancel));
-            // 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,
@@ -223,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 {
@@ -237,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 {
@@ -245,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) {
@@ -258,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 96affe49d..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,7 +43,7 @@ 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,
@@ -74,7 +74,7 @@ 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(";");
            }
@@ -133,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
@@ -142,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));
            }
        }
@@ -170,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<|>);
@@ -186,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<|>;
@@ -206,7 +206,7 @@ fn foo() {
 }"#,
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() {
    <|>{ let x = 0; x }<|>
@@ -221,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;
@@ -237,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<|>)
@@ -254,7 +254,7 @@ fn foo() {
 "#,
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 fn foo() {
    <|>bar(1 + 1)<|>
@@ -270,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;
@@ -295,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;
@@ -327,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<|>;
@@ -344,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<|> };
@@ -361,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)<|>;
@@ -379,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()<|>;
@@ -397,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<|>;
@@ -415,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 {
@@ -436,7 +436,7 @@ fn foo() -> u32 {
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
@@ -453,7 +453,7 @@ fn foo() -> u32 {
        );
        check_assist(
-            introduce_variable,
+            extract_variable,
            "
 fn foo() -> u32 {
    let foo = 1;
@@ -479,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 {
@@ -501,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<|>;
@@ -519,9 +519,9 @@ fn main() {
    }
    #[test]
-    fn introduce_var_field_shorthand() {
+    fn extract_var_field_shorthand() {
        check_assist(
-            introduce_variable,
+            extract_variable,
            r#"
 struct S {
    foo: i32
@@ -545,22 +545,22 @@ fn main() {
    }
    #[test]
-    fn test_introduce_var_for_return_not_applicable() {
+    fn test_extract_var_for_return_not_applicable() {
-        check_assist_not_applicable(introduce_variable, "fn foo() { <|>return<|>; } ");
+        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/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/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index c81b966c3..4d446c707 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -4,14 +4,27 @@
 use hir_expand::name::Name;
 use once_cell::sync::Lazy;
 use ra_db::CrateId;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use test_utils::mark;
 use crate::{
    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
-    Lookup, MacroDefId, ModuleDefId, TraitId,
+    LocalModuleId, Lookup, MacroDefId, ModuleDefId, TraitId,
 };
+#[derive(Copy, Clone)]
+pub(crate) enum ImportType {
+    Glob,
+    Named,
+}
+#[derive(Debug, Default)]
+pub struct PerNsGlobImports {
+    types: FxHashSet<(LocalModuleId, Name)>,
+    values: FxHashSet<(LocalModuleId, Name)>,
+    macros: FxHashSet<(LocalModuleId, Name)>,
+}
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ItemScope {
    visible: FxHashMap<Name, PerNs>,
@@ -127,16 +140,62 @@ impl ItemScope {
        let mut changed = false;
        let existing = self.visible.entry(name).or_default();
+        if existing.types.is_none() && def.types.is_some() {
+            existing.types = def.types;
+            changed = true;
+        }
+        if existing.values.is_none() && def.values.is_some() {
+            existing.values = def.values;
+            changed = true;
+        }
+        if existing.macros.is_none() && def.macros.is_some() {
+            existing.macros = def.macros;
+            changed = true;
+        }
+        changed
+    }
+    pub(crate) fn push_res_with_import(
+        &mut self,
+        glob_imports: &mut PerNsGlobImports,
+        lookup: (LocalModuleId, Name),
+        def: PerNs,
+        def_import_type: ImportType,
+    ) -> bool {
+        let mut changed = false;
+        let existing = self.visible.entry(lookup.1.clone()).or_default();
        macro_rules! check_changed {
-            ($changed:ident, $existing:expr, $def:expr) => {
+            (
-                match ($existing, $def) {
+                $changed:ident,
+                ( $existing:ident / $def:ident ) . $field:ident,
+                $glob_imports:ident [ $lookup:ident ],
+                $def_import_type:ident
+            ) => {
+                match ($existing.$field, $def.$field) {
                    (None, Some(_)) => {
-                        $existing = $def;
+                        match $def_import_type {
+                            ImportType::Glob => {
+                                $glob_imports.$field.insert($lookup.clone());
+                            }
+                            ImportType::Named => {
+                                $glob_imports.$field.remove(&$lookup);
+                            }
+                        }
+                        $existing.$field = $def.$field;
                        $changed = true;
                    }
-                    (Some(e), Some(d)) if e.0 != d.0 => {
+                    (Some(_), Some(_))
+                        if $glob_imports.$field.contains(&$lookup)
+                            && matches!($def_import_type, ImportType::Named) =>
+                    {
                        mark::hit!(import_shadowed);
-                        $existing = $def;
+                        $glob_imports.$field.remove(&$lookup);
+                        $existing.$field = $def.$field;
                        $changed = true;
                    }
                    _ => {}
@@ -144,9 +203,9 @@ impl ItemScope {
            };
        }
-        check_changed!(changed, existing.types, def.types);
+        check_changed!(changed, (existing / def).types, glob_imports[lookup], def_import_type);
-        check_changed!(changed, existing.values, def.values);
+        check_changed!(changed, (existing / def).values, glob_imports[lookup], def_import_type);
-        check_changed!(changed, existing.macros, def.macros);
+        check_changed!(changed, (existing / def).macros, glob_imports[lookup], def_import_type);
        changed
    }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 2ced4f66b..a35ac1024 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -20,6 +20,7 @@ use test_utils::mark;
 use crate::{
    attr::Attrs,
    db::DefDatabase,
+    item_scope::{ImportType, PerNsGlobImports},
    item_tree::{
        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind,
    },
@@ -80,6 +81,7 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
        mod_dirs: FxHashMap::default(),
        cfg_options,
        proc_macros,
+        from_glob_import: Default::default(),
    };
    collector.collect();
    collector.finish()
@@ -186,6 +188,7 @@ struct DefCollector<'a> {
    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
    cfg_options: &'a CfgOptions,
    proc_macros: Vec<(Name, ProcMacroExpander)>,
+    from_glob_import: PerNsGlobImports,
 }
 impl DefCollector<'_> {
@@ -305,6 +308,7 @@ impl DefCollector<'_> {
                self.def_map.root,
                &[(name, PerNs::macros(macro_, Visibility::Public))],
                Visibility::Public,
+                ImportType::Named,
            );
        }
    }
@@ -330,6 +334,7 @@ impl DefCollector<'_> {
            self.def_map.root,
            &[(name, PerNs::macros(macro_, Visibility::Public))],
            Visibility::Public,
+            ImportType::Named,
        );
    }
@@ -383,7 +388,6 @@ impl DefCollector<'_> {
            let imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
            for mut directive in imports {
                directive.status = self.resolve_import(directive.module_id, &directive.import);
                match directive.status {
                    PartialResolvedImport::Indeterminate(_) => {
                        self.record_resolved_import(&directive);
@@ -477,7 +481,7 @@ impl DefCollector<'_> {
                            .filter(|(_, res)| !res.is_none())
                            .collect::<Vec<_>>();
-                        self.update(module_id, &items, vis);
+                        self.update(module_id, &items, vis, ImportType::Glob);
                    } else {
                        // glob import from same crate => we do an initial
                        // import, and then need to propagate any further
@@ -499,7 +503,7 @@ impl DefCollector<'_> {
                            .filter(|(_, res)| !res.is_none())
                            .collect::<Vec<_>>();
-                        self.update(module_id, &items, vis);
+                        self.update(module_id, &items, vis, ImportType::Glob);
                        // record the glob import in case we add further items
                        let glob = self.glob_imports.entry(m.local_id).or_default();
                        if !glob.iter().any(|(mid, _)| *mid == module_id) {
@@ -529,7 +533,7 @@ impl DefCollector<'_> {
                            (name, res)
                        })
                        .collect::<Vec<_>>();
-                    self.update(module_id, &resolutions, vis);
+                    self.update(module_id, &resolutions, vis, ImportType::Glob);
                }
                Some(d) => {
                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
@@ -555,15 +559,21 @@ impl DefCollector<'_> {
                        }
                    }
-                    self.update(module_id, &[(name, def)], vis);
+                    self.update(module_id, &[(name, def)], vis, ImportType::Named);
                }
                None => mark::hit!(bogus_paths),
            }
        }
    }
-    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, PerNs)], vis: Visibility) {
+    fn update(
-        self.update_recursive(module_id, resolutions, vis, 0)
+        &mut self,
+        module_id: LocalModuleId,
+        resolutions: &[(Name, PerNs)],
+        vis: Visibility,
+        import_type: ImportType,
+    ) {
+        self.update_recursive(module_id, resolutions, vis, import_type, 0)
    }
    fn update_recursive(
@@ -573,6 +583,7 @@ impl DefCollector<'_> {
        // All resolutions are imported with this visibility; the visibilies in
        // the `PerNs` values are ignored and overwritten
        vis: Visibility,
+        import_type: ImportType,
        depth: usize,
    ) {
        if depth > 100 {
@@ -582,7 +593,12 @@ impl DefCollector<'_> {
        let scope = &mut self.def_map.modules[module_id].scope;
        let mut changed = false;
        for (name, res) in resolutions {
-            changed |= scope.push_res(name.clone(), res.with_visibility(vis));
+            changed |= scope.push_res_with_import(
+                &mut self.from_glob_import,
+                (module_id, name.clone()),
+                res.with_visibility(vis),
+                import_type,
+            );
        }
        if !changed {
@@ -601,7 +617,13 @@ impl DefCollector<'_> {
            if !vis.is_visible_from_def_map(&self.def_map, glob_importing_module) {
                continue;
            }
-            self.update_recursive(glob_importing_module, resolutions, glob_import_vis, depth + 1);
+            self.update_recursive(
+                glob_importing_module,
+                resolutions,
+                glob_import_vis,
+                ImportType::Glob,
+                depth + 1,
+            );
        }
    }
@@ -923,6 +945,7 @@ impl ModCollector<'_, '_> {
                        self.module_id,
                        &[(name.clone(), PerNs::from_def(id, vis, has_constructor))],
                        vis,
+                        ImportType::Named,
                    )
                }
            }
@@ -1025,7 +1048,12 @@ impl ModCollector<'_, '_> {
        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
        let def: ModuleDefId = module.into();
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis, false))], vis);
+        self.def_collector.update(
+            self.module_id,
+            &[(name, PerNs::from_def(def, vis, false))],
+            vis,
+            ImportType::Named,
+        );
        res
    }
@@ -1154,6 +1182,7 @@ mod tests {
            mod_dirs: FxHashMap::default(),
            cfg_options: &CfgOptions::default(),
            proc_macros: Default::default(),
+            from_glob_import: Default::default(),
        };
        collector.collect();
        collector.def_map
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 2f440975a..7f3d7509c 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -276,3 +276,93 @@ fn glob_shadowed_def() {
    "###
    );
 }
+#[test]
+fn glob_shadowed_def_reversed() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod foo;
+        mod bar;
+        use bar::baz;
+        use foo::*;
+        use baz::Bar;
+        //- /foo.rs
+        pub mod baz {
+            pub struct Foo;
+        }
+        //- /bar.rs
+        pub mod baz {
+            pub struct Bar;
+        }
+        "###,
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮bar: t
+        ⋮baz: t
+        ⋮foo: t
+        ⋮
+        ⋮crate::bar
+        ⋮baz: t
+        ⋮
+        ⋮crate::bar::baz
+        ⋮Bar: t v
+        ⋮
+        ⋮crate::foo
+        ⋮baz: t
+        ⋮
+        ⋮crate::foo::baz
+        ⋮Foo: t v
+    "###
+    );
+}
+#[test]
+fn glob_shadowed_def_dependencies() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod a { pub mod foo { pub struct X; } }
+        mod b { pub use super::a::foo; }
+        mod c { pub mod foo { pub struct Y; } }
+        mod d {
+            use super::c::foo;
+            use super::b::*;
+            use foo::Y;
+        }
+        "###,
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮a: t
+        ⋮b: t
+        ⋮c: t
+        ⋮d: t
+        ⋮
+        ⋮crate::d
+        ⋮Y: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::c
+        ⋮foo: t
+        ⋮
+        ⋮crate::c::foo
+        ⋮Y: t v
+        ⋮
+        ⋮crate::b
+        ⋮foo: t
+        ⋮
+        ⋮crate::a
+        ⋮foo: t
+        ⋮
+        ⋮crate::a::foo
+        ⋮X: t v
+    "###
+    );
+}
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/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/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index d7ef9add6..7d8197f8b 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1739,6 +1739,52 @@ fn main() {
    assert_eq!(t, "u32");
 }
+// This test is actually testing the shadowing behavior within ra_hir_def. It
+// lives here because the testing infrastructure in ra_hir_def isn't currently
+// capable of asserting the necessary conditions.
+#[test]
+fn should_be_shadowing_imports() {
+    let t = type_at(
+        r#"
+mod a {
+    pub fn foo() -> i8 {0}
+    pub struct foo { a: i8 }
+}
+mod b { pub fn foo () -> u8 {0} }
+mod c { pub struct foo { a: u8 } }
+mod d {
+    pub use super::a::*;
+    pub use super::c::foo;
+    pub use super::b::foo;
+}
+fn main() {
+    d::foo()<|>;
+}"#,
+    );
+    assert_eq!(t, "u8");
+    let t = type_at(
+        r#"
+mod a {
+    pub fn foo() -> i8 {0}
+    pub struct foo { a: i8 }
+}
+mod b { pub fn foo () -> u8 {0} }
+mod c { pub struct foo { a: u8 } }
+mod d {
+    pub use super::a::*;
+    pub use super::c::foo;
+    pub use super::b::foo;
+}
+fn main() {
+    d::foo{a:0<|>};
+}"#,
+    );
+    assert_eq!(t, "u8");
+}
 #[test]
 fn closure_return() {
    assert_snapshot!(
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_ssr/src/lib.rs b/crates/ra_ssr/src/lib.rs
index da26ee669..8f149e3db 100644
--- a/crates/ra_ssr/src/lib.rs
+++ b/crates/ra_ssr/src/lib.rs
@@ -12,7 +12,7 @@ mod tests;
 use crate::matching::Match;
 use hir::Semantics;
 use ra_db::{FileId, FileRange};
-use ra_syntax::{AstNode, SmolStr, SyntaxNode};
+use ra_syntax::{ast, AstNode, SmolStr, SyntaxNode};
 use ra_text_edit::TextEdit;
 use rustc_hash::FxHashMap;
@@ -107,6 +107,22 @@ impl<'db> MatchFinder<'db> {
                return;
            }
        }
+        // If we've got a macro call, we already tried matching it pre-expansion, which is the only
+        // way to match the whole macro, now try expanding it and matching the expansion.
+        if let Some(macro_call) = ast::MacroCall::cast(code.clone()) {
+            if let Some(expanded) = self.sema.expand(&macro_call) {
+                if let Some(tt) = macro_call.token_tree() {
+                    // When matching within a macro expansion, we only want to allow matches of
+                    // nodes that originated entirely from within the token tree of the macro call.
+                    // i.e. we don't want to match something that came from the macro itself.
+                    self.find_matches(
+                        &expanded,
+                        &Some(self.sema.original_range(tt.syntax())),
+                        matches_out,
+                    );
+                }
+            }
+        }
        for child in code.children() {
            self.find_matches(&child, restrict_range, matches_out);
        }
diff --git a/crates/ra_ssr/src/matching.rs b/crates/ra_ssr/src/matching.rs
index bdaba9f1b..85420ed3c 100644
--- a/crates/ra_ssr/src/matching.rs
+++ b/crates/ra_ssr/src/matching.rs
@@ -343,7 +343,9 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
    }
    /// Outside of token trees, a placeholder can only match a single AST node, whereas in a token
-    /// tree it can match a sequence of tokens.
+    /// tree it can match a sequence of tokens. Note, that this code will only be used when the
+    /// pattern matches the macro invocation. For matches within the macro call, we'll already have
+    /// expanded the macro.
    fn attempt_match_token_tree(
        &mut self,
        match_inputs: &MatchInputs,
diff --git a/crates/ra_ssr/src/tests.rs b/crates/ra_ssr/src/tests.rs
index 3ee1e74e9..7a3141be8 100644
--- a/crates/ra_ssr/src/tests.rs
+++ b/crates/ra_ssr/src/tests.rs
@@ -209,6 +209,11 @@ fn assert_ssr_transform(rule: &str, input: &str, result: &str) {
    assert_ssr_transforms(&[rule], input, result);
 }
+fn normalize_code(code: &str) -> String {
+    let (db, file_id) = single_file(code);
+    db.file_text(file_id).to_string()
+}
 fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
    let (db, file_id) = single_file(input);
    let mut match_finder = MatchFinder::new(&db);
@@ -217,8 +222,13 @@ fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
        match_finder.add_rule(rule);
    }
    if let Some(edits) = match_finder.edits_for_file(file_id) {
-        let mut after = input.to_string();
+        // Note, db.file_text is not necessarily the same as `input`, since fixture parsing alters
+        // stuff.
+        let mut after = db.file_text(file_id).to_string();
        edits.apply(&mut after);
+        // Likewise, we need to make sure that whatever transformations fixture parsing applies,
+        // also get appplied to our expected result.
+        let result = normalize_code(result);
        assert_eq!(after, result);
    } else {
        panic!("No edits were made");
@@ -355,6 +365,18 @@ fn match_nested_method_calls() {
    );
 }
+// Make sure that our node matching semantics don't differ within macro calls.
+#[test]
+fn match_nested_method_calls_with_macro_call() {
+    assert_matches(
+        "$a.z().z().z()",
+        r#"
+            macro_rules! m1 { ($a:expr) => {$a}; }
+            fn f() {m1!(h().i().j().z().z().z().d().e())}"#,
+        &["h().i().j().z().z().z()"],
+    );
+}
 #[test]
 fn match_complex_expr() {
    let code = "fn f() -> i32 {foo(bar(40, 2), 42)}";
@@ -547,3 +569,40 @@ fn multiple_rules() {
        "fn f() -> i32 {add_one(add(3, 2))}",
    )
 }
+#[test]
+fn match_within_macro_invocation() {
+    let code = r#"
+            macro_rules! foo {
+                ($a:stmt; $b:expr) => {
+                    $b
+                };
+            }
+            struct A {}
+            impl A {
+                fn bar() {}
+            }
+            fn f1() {
+                let aaa = A {};
+                foo!(macro_ignores_this(); aaa.bar());
+            }
+        "#;
+    assert_matches("$a.bar()", code, &["aaa.bar()"]);
+}
+#[test]
+fn replace_within_macro_expansion() {
+    assert_ssr_transform(
+        "$a.foo() ==>> bar($a)",
+        r#"
+            macro_rules! macro1 {
+                ($a:expr) => {$a}
+            }
+            fn f() {macro1!(5.x().foo().o2())}"#,
+        r#"
+            macro_rules! macro1 {
+                ($a:expr) => {$a}
+            }
+            fn f() {macro1!(bar(5.x()).o2())}"#,
+    )
+}
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/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index f3cdb842b..1cf50b677 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -3,7 +3,6 @@ pub(crate) mod to_proto;
 use std::{collections::HashMap, mem, sync::Arc};
-use lsp_types::{Diagnostic, Range};
 use ra_ide::FileId;
 use rustc_hash::FxHashSet;
@@ -19,15 +18,15 @@ pub struct DiagnosticsConfig {
 #[derive(Debug, Default, Clone)]
 pub(crate) struct DiagnosticCollection {
-    pub(crate) native: HashMap<FileId, Vec<Diagnostic>>,
+    pub(crate) native: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
-    pub(crate) check: HashMap<FileId, Vec<Diagnostic>>,
+    pub(crate) check: HashMap<FileId, Vec<lsp_types::Diagnostic>>,
    pub(crate) check_fixes: CheckFixes,
    changes: FxHashSet<FileId>,
 }
 #[derive(Debug, Clone)]
 pub(crate) struct Fix {
-    pub(crate) range: Range,
+    pub(crate) range: lsp_types::Range,
    pub(crate) action: lsp_ext::CodeAction,
 }
@@ -40,7 +39,7 @@ impl DiagnosticCollection {
    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();
@@ -59,12 +58,19 @@ impl DiagnosticCollection {
        self.changes.insert(file_id);
    }
-    pub(crate) 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(crate) 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)
@@ -78,7 +84,7 @@ impl DiagnosticCollection {
    }
 }
-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/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 7533bb319..b8aa1e5b5 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -12,6 +12,7 @@ use parking_lot::RwLock;
 use ra_db::{CrateId, VfsPath};
 use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FileId};
 use ra_project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
+use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
    config::Config,
@@ -21,12 +22,10 @@ use crate::{
    main_loop::Task,
    reload::SourceRootConfig,
    request_metrics::{LatestRequests, RequestMetrics},
-    show_message,
    thread_pool::TaskPool,
    to_proto::url_from_abs_path,
    Result,
 };
-use rustc_hash::{FxHashMap, FxHashSet};
 #[derive(Eq, PartialEq)]
 pub(crate) enum Status {
@@ -58,6 +57,7 @@ pub(crate) type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;
 /// 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>>>,
@@ -67,7 +67,6 @@ pub(crate) struct GlobalState {
    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>>,
@@ -103,16 +102,16 @@ impl GlobalState {
        let analysis_host = AnalysisHost::new(config.lru_capacity);
        GlobalState {
            sender,
+            req_queue: ReqQueue::default(),
            task_pool,
            loader,
+            flycheck: None,
            config,
            analysis_host,
-            flycheck: None,
            diagnostics: Default::default(),
            mem_docs: FxHashSet::default(),
            vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
            status: Status::default(),
-            req_queue: ReqQueue::default(),
            source_root_config: SourceRootConfig::default(),
            proc_macro_client: ProcMacroClient::dummy(),
            workspaces: Arc::new(Vec::new()),
@@ -169,8 +168,35 @@ impl GlobalState {
        }
    }
-    pub(crate) fn send(&mut self, message: lsp_server::Message) {
+    pub(crate) fn send_request<R: lsp_types::request::Request>(
-        self.sender.send(message).unwrap()
+        &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()) {
@@ -182,8 +208,14 @@ impl GlobalState {
            self.send(response.into());
        }
    }
-    pub(crate) fn show_message(&self, typ: lsp_types::MessageType, message: String) {
+    pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
-        show_message(typ, message, &self.sender)
+        if let Some(response) = self.req_queue.incoming.cancel(request_id) {
+            self.send(response.into());
+        }
+    }
+    fn send(&mut self, message: lsp_server::Message) {
+        self.sender.send(message).unwrap()
    }
 }
@@ -195,11 +227,7 @@ impl Drop for GlobalState {
 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 {
@@ -213,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)
    }
@@ -239,3 +267,9 @@ pub(crate) fn file_id_to_url(vfs: &vfs::Vfs, id: FileId) -> Url {
    let path = path.as_path().unwrap();
    url_from_abs_path(&path)
 }
+pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> Result<FileId> {
+    let path = from_proto::vfs_path(url)?;
+    let res = vfs.file_id(&path).ok_or_else(|| format!("file not found: {}", path))?;
+    Ok(res)
+}
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 6c21f25fe..38e3c3324 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -650,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
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index a24dfe58c..407944d85 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -39,7 +39,7 @@ 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 35917030c..0bc3ff115 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -1,24 +1,11 @@
 //! Utilities for LSP-related boilerplate code.
 use std::{error::Error, ops::Range};
-use crossbeam_channel::Sender;
+use lsp_server::Notification;
-use lsp_server::{Message, Notification};
 use ra_db::Canceled;
 use ra_ide::LineIndex;
-use serde::Serialize;
-use crate::from_proto;
+use crate::{from_proto, global_state::GlobalState};
-pub fn show_message(
-    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()
@@ -30,12 +17,68 @@ pub(crate) fn notification_is<N: lsp_types::notification::Notification>(
    notification.method == N::METHOD
 }
-pub(crate) fn notification_new<N>(params: N::Params) -> Notification
+#[derive(Debug, Eq, PartialEq)]
-where
+pub(crate) enum Progress {
-    N: lsp_types::notification::Notification,
+    Begin,
-    N::Params: Serialize,
+    Report,
-{
+    End,
-    Notification::new(N::METHOD.to_string(), params)
+}
+impl Progress {
+    pub(crate) fn percentage(done: usize, total: usize) -> f64 {
+        (done as f64 / total.max(1) as f64) * 100.0
+    }
+}
+impl GlobalState {
+    pub(crate) fn show_message(&mut self, typ: lsp_types::MessageType, message: String) {
+        let message = message.into();
+        self.send_notification::<lsp_types::notification::ShowMessage>(
+            lsp_types::ShowMessageParams { typ, message },
+        )
+    }
+    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 162c0057e..e5194fe41 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -7,7 +7,7 @@ use std::{
 use crossbeam_channel::{never, select, Receiver};
 use lsp_server::{Connection, Notification, Request, Response};
-use lsp_types::{notification::Notification as _, request::Request as _};
+use lsp_types::notification::Notification as _;
 use ra_db::VfsPath;
 use ra_ide::{Canceled, FileId};
 use ra_prof::profile;
@@ -16,9 +16,9 @@ use crate::{
    config::Config,
    dispatch::{NotificationDispatcher, RequestDispatcher},
    from_proto,
-    global_state::{file_id_to_url, GlobalState, Status},
+    global_state::{file_id_to_url, url_to_file_id, GlobalState, Status},
    handlers, lsp_ext,
-    lsp_utils::{apply_document_changes, is_canceled, notification_is, notification_new},
+    lsp_utils::{apply_document_changes, is_canceled, notification_is, Progress},
    Result,
 };
@@ -143,10 +143,7 @@ impl GlobalState {
                lsp_server::Message::Notification(not) => {
                    self.on_notification(not)?;
                }
-                lsp_server::Message::Response(resp) => {
+                lsp_server::Message::Response(resp) => self.complete_request(resp),
-                    let handler = self.req_queue.outgoing.complete(resp.id.clone());
-                    handler(self, resp)
-                }
            },
            Event::Task(task) => {
                match task {
@@ -181,18 +178,15 @@ impl GlobalState {
                        became_ready = true;
                        Progress::End
                    };
-                    report_progress(
+                    self.report_progress(
-                        self,
                        "roots scanned",
                        state,
                        Some(format!("{}/{}", n_done, n_total)),
-                        Some(percentage(n_done, n_total)),
+                        Some(Progress::percentage(n_done, n_total)),
                    )
                }
            },
            Event::Flycheck(task) => match task {
-                flycheck::Message::ClearDiagnostics => self.diagnostics.clear_check(),
                flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
                    let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
                        &self.config.diagnostics,
@@ -200,31 +194,34 @@ impl GlobalState {
                        &workspace_root,
                    );
                    for diag in diagnostics {
-                        let path = from_proto::vfs_path(&diag.location.uri)?;
+                        match url_to_file_id(&self.vfs.read().0, &diag.location.uri) {
-                        let file_id = match self.vfs.read().0.file_id(&path) {
+                            Ok(file_id) => self.diagnostics.add_check_diagnostic(
-                            Some(file) => FileId(file.0),
+                                file_id,
-                            None => {
+                                diag.diagnostic,
-                                log::error!(
+                                diag.fixes,
-                                    "File with cargo diagnostic not found in VFS: {}",
+                            ),
-                                    path
+                            Err(err) => {
-                                );
+                                log::error!("File with cargo diagnostic not found in VFS: {}", err);
-                                return Ok(());
                            }
                        };
-                        self.diagnostics.add_check_diagnostic(file_id, diag.diagnostic, diag.fixes)
                    }
                }
                flycheck::Message::Progress(status) => {
                    let (state, message) = match status {
-                        flycheck::Progress::Being => (Progress::Begin, None),
+                        flycheck::Progress::DidStart => {
+                            self.diagnostics.clear_check();
+                            (Progress::Begin, None)
+                        }
                        flycheck::Progress::DidCheckCrate(target) => {
                            (Progress::Report, Some(target))
                        }
-                        flycheck::Progress::End => (Progress::End, None),
+                        flycheck::Progress::DidFinish | flycheck::Progress::DidCancel => {
+                            (Progress::End, None)
+                        }
                    };
-                    report_progress(self, "cargo check", state, message, None);
+                    self.report_progress("cargo check", state, message, None);
                }
            },
        }
@@ -250,10 +247,9 @@ impl GlobalState {
            for file_id in diagnostic_changes {
                let url = file_id_to_url(&self.vfs.read().0, file_id);
                let diagnostics = self.diagnostics.diagnostics_for(file_id).cloned().collect();
-                let params =
+                self.send_notification::<lsp_types::notification::PublishDiagnostics>(
-                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None };
+                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None },
-                let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
+                );
-                self.send(not.into());
            }
        }
@@ -271,7 +267,7 @@ impl GlobalState {
    }
    fn on_request(&mut self, request_received: Instant, req: Request) -> Result<()> {
-        self.req_queue.incoming.register(req.id.clone(), (req.method.clone(), request_received));
+        self.register_request(&req, request_received);
        RequestDispatcher { req: Some(req), global_state: self }
            .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.analysis_host.collect_garbage()))?
@@ -335,9 +331,7 @@ impl GlobalState {
                    lsp_types::NumberOrString::Number(id) => id.into(),
                    lsp_types::NumberOrString::String(id) => id.into(),
                };
-                if let Some(response) = this.req_queue.incoming.cancel(id) {
+                this.cancel(id);
-                    this.send(response.into());
-                }
                Ok(())
            })?
            .on::<lsp_types::notification::DidOpenTextDocument>(|this, params| {
@@ -372,13 +366,13 @@ impl GlobalState {
                        this.loader.handle.invalidate(path.to_path_buf());
                    }
                }
-                let params = lsp_types::PublishDiagnosticsParams {
+                this.send_notification::<lsp_types::notification::PublishDiagnostics>(
-                    uri: params.text_document.uri,
+                    lsp_types::PublishDiagnosticsParams {
-                    diagnostics: Vec::new(),
+                        uri: params.text_document.uri,
-                    version: None,
+                        diagnostics: Vec::new(),
-                };
+                        version: None,
-                let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
+                    },
-                this.send(not.into());
+                );
                Ok(())
            })?
            .on::<lsp_types::notification::DidSaveTextDocument>(|this, _params| {
@@ -390,8 +384,7 @@ impl GlobalState {
            .on::<lsp_types::notification::DidChangeConfiguration>(|this, _params| {
                // As stated in https://github.com/microsoft/language-server-protocol/issues/676,
                // this notification's parameters should be ignored and the actual config queried separately.
-                let request = this.req_queue.outgoing.register(
+                this.send_request::<lsp_types::request::WorkspaceConfiguration>(
-                    lsp_types::request::WorkspaceConfiguration::METHOD.to_string(),
                    lsp_types::ConfigurationParams {
                        items: vec![lsp_types::ConfigurationItem {
                            scope_uri: None,
@@ -419,7 +412,6 @@ impl GlobalState {
                        }
                    },
                );
-                this.send(request.into());
                return Ok(());
            })?
@@ -467,60 +459,3 @@ impl GlobalState {
        });
    }
 }
-#[derive(Eq, PartialEq)]
-enum Progress {
-    Begin,
-    Report,
-    End,
-}
-fn percentage(done: usize, total: usize) -> f64 {
-    (done as f64 / total.max(1) as f64) * 100.0
-}
-fn report_progress(
-    global_state: &mut GlobalState,
-    title: &str,
-    state: Progress,
-    message: Option<String>,
-    percentage: Option<f64>,
-) {
-    if !global_state.config.client_caps.work_done_progress {
-        return;
-    }
-    let token = lsp_types::ProgressToken::String(format!("rustAnalyzer/{}", title));
-    let work_done_progress = match state {
-        Progress::Begin => {
-            let work_done_progress_create = global_state.req_queue.outgoing.register(
-                lsp_types::request::WorkDoneProgressCreate::METHOD.to_string(),
-                lsp_types::WorkDoneProgressCreateParams { token: token.clone() },
-                |_, _| (),
-            );
-            global_state.send(work_done_progress_create.into());
-            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 })
-        }
-    };
-    let notification =
-        notification_new::<lsp_types::notification::Progress>(lsp_types::ProgressParams {
-            token,
-            value: lsp_types::ProgressParamsValue::WorkDone(work_done_progress),
-        });
-    global_state.send(notification.into());
-}
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index a22d3e262..ec71f8b29 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -1,9 +1,8 @@
 //! Project loading & configuration updates
-use std::sync::Arc;
+use std::{mem, sync::Arc};
 use crossbeam_channel::unbounded;
 use flycheck::FlycheckHandle;
-use lsp_types::request::Request;
 use ra_db::{CrateGraph, SourceRoot, VfsPath};
 use ra_ide::AnalysisChange;
 use ra_project_model::{PackageRoot, ProcMacroClient, ProjectWorkspace};
@@ -15,12 +14,14 @@ use crate::{
 };
 impl GlobalState {
-    pub(crate) fn update_configuration(&mut self, new_config: Config) {
+    pub(crate) fn update_configuration(&mut self, config: Config) {
-        self.analysis_host.update_lru_capacity(new_config.lru_capacity);
+        let old_config = mem::replace(&mut self.config, config);
-        if new_config.flycheck != self.config.flycheck {
+        if self.config.lru_capacity != old_config.lru_capacity {
+            self.analysis_host.update_lru_capacity(old_config.lru_capacity);
+        }
+        if self.config.flycheck != old_config.flycheck {
            self.reload_flycheck();
        }
-        self.config = new_config;
    }
    pub(crate) fn reload(&mut self) {
        let workspaces = {
@@ -36,27 +37,31 @@ impl GlobalState {
            self.config
                .linked_projects
                .iter()
-                .filter_map(|project| match project {
+                .map(|project| match project {
                    LinkedProject::ProjectManifest(manifest) => {
                        ra_project_model::ProjectWorkspace::load(
                            manifest.clone(),
                            &self.config.cargo,
                            self.config.with_sysroot,
                        )
-                        .map_err(|err| {
-                            log::error!("failed to load workspace: {:#}", err);
-                            self.show_message(
-                                lsp_types::MessageType::Error,
-                                format!("rust-analyzer failed to load workspace: {:#}", err),
-                            );
-                        })
-                        .ok()
                    }
                    LinkedProject::InlineJsonProject(it) => {
-                        Some(ra_project_model::ProjectWorkspace::Json { project: it.clone() })
+                        Ok(ra_project_model::ProjectWorkspace::Json { project: it.clone() })
                    }
                })
                .collect::<Vec<_>>()
+                .into_iter()
+                .filter_map(|res| {
+                    res.map_err(|err| {
+                        log::error!("failed to load workspace: {:#}", err);
+                        self.show_message(
+                            lsp_types::MessageType::Error,
+                            format!("rust-analyzer failed to load workspace: {:#}", err),
+                        );
+                    })
+                    .ok()
+                })
+                .collect::<Vec<_>>()
        };
        if let FilesWatcher::Client = self.config.files.watcher {
@@ -74,13 +79,10 @@ impl GlobalState {
                method: "workspace/didChangeWatchedFiles".to_string(),
                register_options: Some(serde_json::to_value(registration_options).unwrap()),
            };
-            let params = lsp_types::RegistrationParams { registrations: vec![registration] };
+            self.send_request::<lsp_types::request::RegisterCapability>(
-            let request = self.req_queue.outgoing.register(
+                lsp_types::RegistrationParams { registrations: vec![registration] },
-                lsp_types::request::RegisterCapability::METHOD.to_string(),
-                params,
                |_, _| (),
            );
-            self.send(request.into());
        }
        let mut change = AnalysisChange::new();
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 0173f7464..d0ddeafe7 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -18,7 +18,7 @@ impl FileSet {
    pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
        let mut base = self.paths[&anchor].clone();
        base.pop();
-        let path = base.join(path);
+        let path = base.join(path)?;
        let res = self.files.get(&path).copied();
        res
    }
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 940f91d0e..dc3031ada 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -22,15 +22,15 @@ impl VfsPath {
            VfsPathRepr::VirtualPath(_) => None,
        }
    }
-    pub fn join(&self, path: &str) -> VfsPath {
+    pub fn join(&self, path: &str) -> Option<VfsPath> {
        match &self.0 {
            VfsPathRepr::PathBuf(it) => {
                let res = it.join(path).normalize();
-                VfsPath(VfsPathRepr::PathBuf(res))
+                Some(VfsPath(VfsPathRepr::PathBuf(res)))
            }
            VfsPathRepr::VirtualPath(it) => {
-                let res = it.join(path);
+                let res = it.join(path)?;
-                VfsPath(VfsPathRepr::VirtualPath(res))
+                Some(VfsPath(VfsPathRepr::VirtualPath(res)))
            }
        }
    }
@@ -101,13 +101,15 @@ impl VirtualPath {
        self.0 = self.0[..pos].to_string();
        true
    }
-    fn join(&self, mut path: &str) -> VirtualPath {
+    fn join(&self, mut path: &str) -> Option<VirtualPath> {
        let mut res = self.clone();
        while path.starts_with("../") {
-            assert!(res.pop());
+            if !res.pop() {
+                return None;
+            }
            path = &path["../".len()..]
        }
        res.0 = format!("{}/{}", res.0, path);
-        res
+        Some(res)
    }
 }
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 76e1da6cf..11dc5261b 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -166,6 +166,17 @@ That said, adding an innocent-looking `pub use` is a very simple way to break en
 Note: if you enjoyed this abstract hand-waving about boundaries, you might appreciate
 https://www.tedinski.com/2018/02/06/system-boundaries.html
+## Minimal Tests
+Most tests in rust-analyzer start with a snippet of Rust code.
+This snippets should be minimal -- if you copy-paste a snippet of real code into the tests, make sure to remove everything which could be removed.
+There are many benefits to this:
+* less to read or to scroll past
+* easier to understand what exactly is tested
+* less stuff printed during printf-debugging
+* less time to run test
 ## Order of Imports
 We separate import groups with blank lines
diff --git a/editors/code/package.json b/editors/code/package.json
index 68484a370..f542a490a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -336,6 +336,14 @@
                    "default": null,
                    "description": "List of features to activate. Defaults to `rust-analyzer.cargo.features`."
                },
+                "rust-analyzer.cargoRunner": {
+                    "type": [
+                        "null",
+                        "string"
+                    ],
+                    "default": null,
+                    "description": "Custom cargo runner extension ID."
+                },
                "rust-analyzer.inlayHints.enable": {
                    "type": "boolean",
                    "default": true,
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 48a25495f..8c9d7802f 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -394,7 +394,7 @@ export function run(ctx: Ctx): Cmd {
        item.detail = 'rerun';
        prevRunnable = item;
-        const task = createTask(item.runnable);
+        const task = await createTask(item.runnable, ctx.config);
        return await vscode.tasks.executeTask(task);
    };
 }
@@ -404,7 +404,7 @@ export function runSingle(ctx: Ctx): Cmd {
        const editor = ctx.activeRustEditor;
        if (!editor) return;
-        const task = createTask(runnable);
+        const task = await createTask(runnable, ctx.config);
        task.group = vscode.TaskGroup.Build;
        task.presentationOptions = {
            reveal: vscode.TaskRevealKind.Always,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 9591d4fe3..fc95a7de6 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -110,6 +110,10 @@ export class Config {
        };
    }
+    get cargoRunner() {
+        return this.get<string | undefined>("cargoRunner");
+    }
    get debug() {
        // "/rustc/<id>" used by suggestions only.
        const { ["/rustc/<id>"]: _, ...sourceFileMap } = this.get<Record<string, string>>("debug.sourceFileMap");
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index cdb63b46f..5ceab8b44 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -114,7 +114,7 @@ export async function activate(context: vscode.ExtensionContext) {
    ctx.registerCommand('applyActionGroup', commands.applyActionGroup);
    ctx.registerCommand('gotoLocation', commands.gotoLocation);
-    ctx.pushCleanup(activateTaskProvider(workspaceFolder));
+    ctx.pushCleanup(activateTaskProvider(workspaceFolder, ctx.config));
    activateInlayHints(ctx);
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index bb060cfe1..766b05112 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -1,10 +1,11 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import * as ra from './lsp_ext';
-import * as toolchain from "./toolchain";
+import * as tasks from './tasks';
 import { Ctx } from './ctx';
 import { makeDebugConfig } from './debug';
+import { Config } from './config';
 const quickPickButtons = [{ iconPath: new vscode.ThemeIcon("save"), tooltip: "Save as a launch.json configurtation." }];
@@ -95,52 +96,29 @@ export class RunnableQuickPick implements vscode.QuickPickItem {
    }
 }
-interface CargoTaskDefinition extends vscode.TaskDefinition {
+export async function createTask(runnable: ra.Runnable, config: Config): Promise<vscode.Task> {
-    type: 'cargo';
+    if (runnable.kind !== "cargo") {
-    label: string;
+        // rust-analyzer supports only one kind, "cargo"
-    command: string;
+        // do not use tasks.TASK_TYPE here, these are completely different meanings.
-    args: string[];
-    env?: { [key: string]: string };
-}
-export function createTask(runnable: ra.Runnable): vscode.Task {
-    const TASK_SOURCE = 'Rust';
-    let command;
+        throw `Unexpected runnable kind: ${runnable.kind}`;
-    switch (runnable.kind) {
-        case "cargo": command = toolchain.getPathForExecutable("cargo");
    }
    const args = [...runnable.args.cargoArgs]; // should be a copy!
    if (runnable.args.executableArgs.length > 0) {
        args.push('--', ...runnable.args.executableArgs);
    }
-    const definition: CargoTaskDefinition = {
+    const definition: tasks.CargoTaskDefinition = {
-        type: 'cargo',
+        type: tasks.TASK_TYPE,
-        label: runnable.label,
+        command: args[0], // run, test, etc...
-        command,
+        args: args.slice(1),
-        args,
+        cwd: runnable.args.workspaceRoot,
        env: Object.assign({}, process.env as { [key: string]: string }, { "RUST_BACKTRACE": "short" }),
    };
-    const execOption: vscode.ShellExecutionOptions = {
+    const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate()
-        cwd: runnable.args.workspaceRoot || '.',
+    const cargoTask = await tasks.buildCargoTask(target, definition, runnable.label, args, config.cargoRunner, true);
-        env: definition.env,
+    cargoTask.presentationOptions.clear = true;
-    };
-    const exec = new vscode.ShellExecution(
+    return cargoTask;
-        definition.command,
-        definition.args,
-        execOption,
-    );
-    const f = vscode.workspace.workspaceFolders![0];
-    const t = new vscode.Task(
-        definition,
-        f,
-        definition.label,
-        TASK_SOURCE,
-        exec,
-        ['$rustc'],
-    );
-    t.presentationOptions.clear = true;
-    return t;
 }
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index 9748824df..14abbd5b7 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -1,11 +1,14 @@
 import * as vscode from 'vscode';
 import * as toolchain from "./toolchain";
+import { Config } from './config';
+import { log } from './util';
 // This ends up as the `type` key in tasks.json. RLS also uses `cargo` and
 // our configuration should be compatible with it so use the same key.
-const TASK_TYPE = 'cargo';
+export const TASK_TYPE = 'cargo';
+export const TASK_SOURCE = 'rust';
-interface CargoTaskDefinition extends vscode.TaskDefinition {
+export interface CargoTaskDefinition extends vscode.TaskDefinition {
    command?: string;
    args?: string[];
    cwd?: string;
@@ -14,73 +17,101 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
 class CargoTaskProvider implements vscode.TaskProvider {
    private readonly target: vscode.WorkspaceFolder;
+    private readonly config: Config;
-    constructor(target: vscode.WorkspaceFolder) {
+    constructor(target: vscode.WorkspaceFolder, config: Config) {
        this.target = target;
+        this.config = config;
    }
-    provideTasks(): vscode.Task[] {
+    async provideTasks(): Promise<vscode.Task[]> {
        // Detect Rust tasks. Currently we do not do any actual detection
        // of tasks (e.g. aliases in .cargo/config) and just return a fixed
        // set of tasks that always exist. These tasks cannot be removed in
        // tasks.json - only tweaked.
-        const cargoPath = toolchain.cargoPath();
+        const defs = [
-        return [
            { command: 'build', group: vscode.TaskGroup.Build },
            { command: 'check', group: vscode.TaskGroup.Build },
            { command: 'test', group: vscode.TaskGroup.Test },
            { command: 'clean', group: vscode.TaskGroup.Clean },
            { command: 'run', group: undefined },
-        ]
+        ];
-            .map(({ command, group }) => {
-                const vscodeTask = new vscode.Task(
+        const tasks: vscode.Task[] = [];
-                    // The contents of this object end up in the tasks.json entries.
+        for (const def of defs) {
-                    {
+            const vscodeTask = await buildCargoTask(this.target, { type: TASK_TYPE, command: def.command }, `cargo ${def.command}`, [def.command], this.config.cargoRunner);
-                        type: TASK_TYPE,
+            vscodeTask.group = def.group;
-                        command,
+            tasks.push(vscodeTask);
-                    },
+        }
-                    // The scope of the task - workspace or specific folder (global
-                    // is not supported).
+        return tasks;
-                    this.target,
-                    // The task name, and task source. These are shown in the UI as
-                    // `${source}: ${name}`, e.g. `rust: cargo build`.
-                    `cargo ${command}`,
-                    'rust',
-                    // What to do when this command is executed.
-                    new vscode.ShellExecution(cargoPath, [command]),
-                    // Problem matchers.
-                    ['$rustc'],
-                );
-                vscodeTask.group = group;
-                return vscodeTask;
-            });
    }
-    resolveTask(task: vscode.Task): vscode.Task | undefined {
+    async resolveTask(task: vscode.Task): Promise<vscode.Task | undefined> {
        // VSCode calls this for every cargo task in the user's tasks.json,
        // we need to inform VSCode how to execute that command by creating
        // a ShellExecution for it.
        const definition = task.definition as CargoTaskDefinition;
-        if (definition.type === 'cargo' && definition.command) {
+        if (definition.type === TASK_TYPE && definition.command) {
            const args = [definition.command].concat(definition.args ?? []);
-            return new vscode.Task(
+            return await buildCargoTask(this.target, definition, task.name, args, this.config.cargoRunner);
-                definition,
-                task.name,
-                'rust',
-                new vscode.ShellExecution('cargo', args, definition),
-            );
        }
        return undefined;
    }
 }
-export function activateTaskProvider(target: vscode.WorkspaceFolder): vscode.Disposable {
+export async function buildCargoTask(
-    const provider = new CargoTaskProvider(target);
+    target: vscode.WorkspaceFolder,
+    definition: CargoTaskDefinition,
+    name: string,
+    args: string[],
+    customRunner?: string,
+    throwOnError: boolean = false
+): Promise<vscode.Task> {
+    let exec: vscode.ShellExecution | undefined = undefined;
+    if (customRunner) {
+        const runnerCommand = `${customRunner}.buildShellExecution`;
+        try {
+            const runnerArgs = { kind: TASK_TYPE, args, cwd: definition.cwd, env: definition.env };
+            const customExec = await vscode.commands.executeCommand(runnerCommand, runnerArgs);
+            if (customExec) {
+                if (customExec instanceof vscode.ShellExecution) {
+                    exec = customExec;
+                } else {
+                    log.debug("Invalid cargo ShellExecution", customExec);
+                    throw "Invalid cargo ShellExecution.";
+                }
+            }
+            // fallback to default processing
+        } catch (e) {
+            if (throwOnError) throw `Cargo runner '${customRunner}' failed! ${e}`;
+            // fallback to default processing
+        }
+    }
+    if (!exec) {
+        exec = new vscode.ShellExecution(toolchain.cargoPath(), args, definition);
+    }
+    return new vscode.Task(
+        definition,
+        target,
+        name,
+        TASK_SOURCE,
+        exec,
+        ['$rustc']
+    );
+}
+export function activateTaskProvider(target: vscode.WorkspaceFolder, config: Config): vscode.Disposable {
+    const provider = new CargoTaskProvider(target, config);
    return vscode.tasks.registerTaskProvider(TASK_TYPE, provider);
 }