12 files changed, 293 insertions, 275 deletions

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 {
-                    CheckEvent::Begin => {
-                        self.send(Message::Progress(Progress::Being));
-                    }
-
-                    CheckEvent::End => {
-                        self.send(Message::Progress(Progress::End));
-                    }
-
-                    CheckEvent::Msg(cargo_metadata::Message::CompilerArtifact(msg)) => {
+                Event::CheckEvent(Some(message)) => match message {
+                    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(_))
-                    | CheckEvent::Msg(cargo_metadata::Message::BuildFinished(_))
-                    | CheckEvent::Msg(cargo_metadata::Message::TextLine(_))
-                    | CheckEvent::Msg(cargo_metadata::Message::Unknown) => {}
+                    cargo_metadata::Message::BuildScriptExecuted(_)
+                    | cargo_metadata::Message::BuildFinished(_)
+                    | cargo_metadata::Message::TextLine(_)
+                    | 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 {
-        if let Some(_last_update_req) = &self.last_update_req {
-            // We currently only request an update on save, as we need up to
-            // date source on disk for cargo check to do it's magic, so we
-            // don't really need to debounce the requests at this point.
-            return true;
+    fn cancel_check_process(&mut self) {
+        if self.check_process.take().is_some() {
+            self.send(Message::Progress(Progress::DidCancel));
         }
-        false
     }
-
-    fn restart_check_process(&mut self) {
-        // First, clear and cancel the old thread
-        self.check_process = None;
-
+    fn start_check_process(&self) -> (Receiver<cargo_metadata::Message>, jod_thread::JoinHandle) {
         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<") {
-        return None;
+    let ret_type_str = type_ref.syntax().text().to_string();
+    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_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>())
-            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value)
-            .unwrap_or_else(|| panic!("couldn't find inner item for {:?}", id))
+            .filter_map(|mod_item| mod_item.downcast::<N>())
+            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value.upcast())
+            .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(ast_id.map(|id| id.upcast()));
+                        let id = self.find_inner_item(&def)?;
                         (
-                            FunctionLoc { container: container.into(), id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
+                            FunctionLoc { container: container.into(), id }.intern(self.db).into(),
                             def.name(),
                         )
                     }
                     ast::ModuleItem::TypeAliasDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        let id = self.find_inner_item(&def)?;
                         (
-                            TypeAliasLoc { container: container.into(), id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
+                            TypeAliasLoc { container: container.into(), id }.intern(self.db).into(),
                             def.name(),
                         )
                     }
                     ast::ModuleItem::ConstDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        let id = self.find_inner_item(&def)?;
                         (
-                            ConstLoc { container: container.into(), id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
+                            ConstLoc { container: container.into(), id }.intern(self.db).into(),
                             def.name(),
                         )
                     }
                     ast::ModuleItem::StaticDef(def) => {
-                        let ast_id = self.expander.ast_id(&def);
-                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
-                        (
-                            StaticLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
+                        let id = self.find_inner_item(&def)?;
+                        (StaticLoc { container, 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(ast_id.map(|id| id.upcast()));
-                        (
-                            StructLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
+                        let id = self.find_inner_item(&def)?;
+                        (StructLoc { container, 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(ast_id.map(|id| id.upcast()));
-                        (
-                            EnumLoc { container, id: ast_id.with_value(id) }.intern(self.db).into(),
-                            def.name(),
-                        )
+                        let id = self.find_inner_item(&def)?;
+                        (EnumLoc { container, 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(ast_id.map(|id| id.upcast()));
-                        (
-                            UnionLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
+                        let id = self.find_inner_item(&def)?;
+                        (UnionLoc { container, 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(ast_id.map(|id| id.upcast()));
-                        (
-                            TraitLoc { container, id: ast_id.with_value(id) }
-                                .intern(self.db)
-                                .into(),
-                            def.name(),
-                        )
+                        let id = self.find_inner_item(&def)?;
+                        (TraitLoc { container, 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/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/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 4da094083..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) {
-        self.sender.send(message).unwrap()
+    pub(crate) fn send_request<R: lsp_types::request::Request>(
+        &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) {
-        show_message(typ, message, &self.sender)
+    pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
+        if let Some(response) = self.req_queue.incoming.cancel(request_id) {
+            self.send(response.into());
+        }
+    }
+
+    fn send(&mut self, message: lsp_server::Message) {
+        self.sender.send(message).unwrap()
     }
 }
 
@@ -209,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)
     }
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::{Message, Notification};
+use lsp_server::Notification;
 use ra_db::Canceled;
 use ra_ide::LineIndex;
-use serde::Serialize;
 
-use crate::from_proto;
-
-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();
-}
+use crate::{from_proto, global_state::GlobalState};
 
 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
-where
-    N: lsp_types::notification::Notification,
-    N::Params: Serialize,
-{
-    Notification::new(N::METHOD.to_string(), params)
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) enum Progress {
+    Begin,
+    Report,
+    End,
+}
+
+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 8fc816cbd..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;
@@ -18,7 +18,7 @@ use crate::{
     from_proto,
     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) => {
-                    let handler = self.req_queue.outgoing.complete(resp.id.clone());
-                    handler(self, resp)
-                }
+                lsp_server::Message::Response(resp) => self.complete_request(resp),
             },
             Event::Task(task) => {
                 match task {
@@ -181,18 +178,15 @@ impl GlobalState {
                         became_ready = true;
                         Progress::End
                     };
-                    report_progress(
-                        self,
+                    self.report_progress(
                         "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,
@@ -215,14 +209,19 @@ impl GlobalState {
 
                 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);
                 }
             },
         }
@@ -248,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 =
-                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None };
-                let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
-                self.send(not.into());
+                self.send_notification::<lsp_types::notification::PublishDiagnostics>(
+                    lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None },
+                );
             }
         }
 
@@ -269,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()))?
@@ -333,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.send(response.into());
-                }
+                this.cancel(id);
                 Ok(())
             })?
             .on::<lsp_types::notification::DidOpenTextDocument>(|this, params| {
@@ -370,13 +366,13 @@ impl GlobalState {
                         this.loader.handle.invalidate(path.to_path_buf());
                     }
                 }
-                let params = lsp_types::PublishDiagnosticsParams {
-                    uri: params.text_document.uri,
-                    diagnostics: Vec::new(),
-                    version: None,
-                };
-                let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
-                this.send(not.into());
+                this.send_notification::<lsp_types::notification::PublishDiagnostics>(
+                    lsp_types::PublishDiagnosticsParams {
+                        uri: params.text_document.uri,
+                        diagnostics: Vec::new(),
+                        version: None,
+                    },
+                );
                 Ok(())
             })?
             .on::<lsp_types::notification::DidSaveTextDocument>(|this, _params| {
@@ -388,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(
-                    lsp_types::request::WorkspaceConfiguration::METHOD.to_string(),
+                this.send_request::<lsp_types::request::WorkspaceConfiguration>(
                     lsp_types::ConfigurationParams {
                         items: vec![lsp_types::ConfigurationItem {
                             scope_uri: None,
@@ -417,7 +412,6 @@ impl GlobalState {
                         }
                     },
                 );
-                this.send(request.into());
 
                 return Ok(());
             })?
@@ -465,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) {
-        self.analysis_host.update_lru_capacity(new_config.lru_capacity);
-        if new_config.flycheck != self.config.flycheck {
+    pub(crate) fn update_configuration(&mut self, config: Config) {
+        let old_config = mem::replace(&mut self.config, config);
+        if self.config.lru_capacity != old_config.lru_capacity {
+            self.analysis_host.update_lru_capacity(old_config.lru_capacity);
+        }
+        if self.config.flycheck != old_config.flycheck {
             self.reload_flycheck();
         }
-        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] };
-            let request = self.req_queue.outgoing.register(
-                lsp_types::request::RegisterCapability::METHOD.to_string(),
-                params,
+            self.send_request::<lsp_types::request::RegisterCapability>(
+                lsp_types::RegistrationParams { registrations: vec![registration] },
                 |_, _| (),
             );
-            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);
-                VfsPath(VfsPathRepr::VirtualPath(res))
+                let res = it.join(path)?;
+                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)
     }
 }