11 files changed, 359 insertions, 278 deletions

diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 11cdf9c34..d84e1598b 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,5 +1,6 @@
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
+use parking_lot::Mutex;
 use ra_syntax::{SyntaxNode, TreeArc, SmolStr, ast};
 use ra_db::{SourceDatabase, salsa};
 
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index fc90f56d5..db78f25ca 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -1,6 +1,7 @@
 //! Trait solving using Chalk.
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
+use parking_lot::Mutex;
 use rustc_hash::FxHashSet;
 use log::debug;
 use chalk_ir::cast::Cast;
@@ -61,7 +62,7 @@ fn solve(
     let context = ChalkContext { db, krate };
     let solver = db.solver(krate);
     debug!("solve goal: {:?}", goal);
-    let solution = solver.lock().unwrap().solve_with_fuel(&context, goal, Some(1000));
+    let solution = solver.lock().solve_with_fuel(&context, goal, Some(1000));
     debug!("solve({:?}) => {:?}", goal, solution);
     solution
 }
diff --git a/crates/ra_lsp_server/src/cargo_target_spec.rs b/crates/ra_lsp_server/src/cargo_target_spec.rs
index cdf2ec10b..742361155 100644
--- a/crates/ra_lsp_server/src/cargo_target_spec.rs
+++ b/crates/ra_lsp_server/src/cargo_target_spec.rs
@@ -1,13 +1,13 @@
 use crate::{
     project_model::{self, TargetKind},
-    server_world::ServerWorld,
+    world::WorldSnapshot,
     Result
 };
 
 use ra_ide_api::{FileId, RunnableKind};
 
 pub(crate) fn runnable_args(
-    world: &ServerWorld,
+    world: &WorldSnapshot,
     file_id: FileId,
     kind: &RunnableKind,
 ) -> Result<Vec<String>> {
@@ -58,7 +58,7 @@ pub struct CargoTargetSpec {
 }
 
 impl CargoTargetSpec {
-    pub fn for_file(world: &ServerWorld, file_id: FileId) -> Result<Option<CargoTargetSpec>> {
+    pub fn for_file(world: &WorldSnapshot, file_id: FileId) -> Result<Option<CargoTargetSpec>> {
         let &crate_id = match world.analysis().crate_for(file_id)?.first() {
             Some(crate_id) => crate_id,
             None => return Ok(None),
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 1b349d02a..88d29b256 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -12,7 +12,7 @@ use ra_ide_api::{
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 
-use crate::{req, server_world::ServerWorld, Result};
+use crate::{req, world::WorldSnapshot, Result};
 
 pub trait Conv {
     type Output;
@@ -228,49 +228,49 @@ impl<T: ConvWith> ConvWith for Option<T> {
 }
 
 impl<'a> TryConvWith for &'a Url {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FileId;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FileId> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
         world.uri_to_file_id(self)
     }
 }
 
 impl TryConvWith for FileId {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = Url;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<Url> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<Url> {
         world.file_id_to_uri(self)
     }
 }
 
 impl<'a> TryConvWith for &'a TextDocumentItem {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FileId;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FileId> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
         self.uri.try_conv_with(world)
     }
 }
 
 impl<'a> TryConvWith for &'a VersionedTextDocumentIdentifier {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FileId;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FileId> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
         self.uri.try_conv_with(world)
     }
 }
 
 impl<'a> TryConvWith for &'a TextDocumentIdentifier {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FileId;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FileId> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> {
         world.uri_to_file_id(&self.uri)
     }
 }
 
 impl<'a> TryConvWith for &'a TextDocumentPositionParams {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FilePosition;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FilePosition> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FilePosition> {
         let file_id = self.text_document.try_conv_with(world)?;
         let line_index = world.analysis().file_line_index(file_id);
         let offset = self.position.conv_with(&line_index);
@@ -279,9 +279,9 @@ impl<'a> TryConvWith for &'a TextDocumentPositionParams {
 }
 
 impl<'a> TryConvWith for (&'a TextDocumentIdentifier, Range) {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = FileRange;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<FileRange> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileRange> {
         let file_id = self.0.try_conv_with(world)?;
         let line_index = world.analysis().file_line_index(file_id);
         let range = self.1.conv_with(&line_index);
@@ -302,9 +302,9 @@ impl<T: TryConvWith> TryConvWith for Vec<T> {
 }
 
 impl TryConvWith for SourceChange {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = req::SourceChange;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<req::SourceChange> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<req::SourceChange> {
         let cursor_position = match self.cursor_position {
             None => None,
             Some(pos) => {
@@ -342,9 +342,9 @@ impl TryConvWith for SourceChange {
 }
 
 impl TryConvWith for SourceFileEdit {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = TextDocumentEdit;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<TextDocumentEdit> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<TextDocumentEdit> {
         let text_document = VersionedTextDocumentIdentifier {
             uri: self.file_id.try_conv_with(world)?,
             version: None,
@@ -356,9 +356,9 @@ impl TryConvWith for SourceFileEdit {
 }
 
 impl TryConvWith for FileSystemEdit {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = ResourceOp;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<ResourceOp> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<ResourceOp> {
         let res = match self {
             FileSystemEdit::CreateFile { source_root, path } => {
                 let uri = world.path_to_uri(source_root, &path)?;
@@ -375,9 +375,9 @@ impl TryConvWith for FileSystemEdit {
 }
 
 impl TryConvWith for &NavigationTarget {
-    type Ctx = ServerWorld;
+    type Ctx = WorldSnapshot;
     type Output = Location;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<Location> {
+    fn try_conv_with(self, world: &WorldSnapshot) -> Result<Location> {
         let line_index = world.analysis().file_line_index(self.file_id());
         let range = self.range();
         to_location(self.file_id(), range, &world, &line_index)
@@ -386,7 +386,7 @@ impl TryConvWith for &NavigationTarget {
 
 pub fn to_location_link(
     target: &RangeInfo<NavigationTarget>,
-    world: &ServerWorld,
+    world: &WorldSnapshot,
     // line index for original range file
     line_index: &LineIndex,
 ) -> Result<LocationLink> {
@@ -410,7 +410,7 @@ pub fn to_location_link(
 pub fn to_location(
     file_id: FileId,
     range: TextRange,
-    world: &ServerWorld,
+    world: &WorldSnapshot,
     line_index: &LineIndex,
 ) -> Result<Location> {
     let url = file_id.try_conv_with(world)?;
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 113883bdd..aabde420b 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -7,7 +7,7 @@ mod project_model;
 mod vfs_filter;
 pub mod req;
 pub mod init;
-mod server_world;
+mod world;
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
 pub use crate::{caps::server_capabilities, main_loop::main_loop, main_loop::LspError, init::InitializationOptions};
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index d29ba94e7..6080a3a4e 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -1,7 +1,8 @@
 mod handlers;
 mod subscriptions;
+pub(crate) mod pending_requests;
 
-use std::{fmt, path::PathBuf, sync::Arc, time::Instant, any::TypeId};
+use std::{fmt, path::PathBuf, sync::Arc, time::Instant};
 
 use crossbeam_channel::{select, unbounded, Receiver, RecvError, Sender};
 use failure::{bail, format_err};
@@ -12,19 +13,24 @@ use gen_lsp_server::{
 use lsp_types::NumberOrString;
 use ra_ide_api::{Canceled, FileId, LibraryData};
 use ra_vfs::VfsTask;
-use rustc_hash::FxHashMap;
 use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
+use ra_prof::profile;
 
 use crate::{
-    main_loop::subscriptions::Subscriptions,
+    main_loop::{
+        subscriptions::Subscriptions,
+        pending_requests::{PendingRequests, PendingRequest},
+    },
     project_model::workspace_loader,
     req,
-    server_world::{ServerWorld, ServerWorldState, CompletedRequest},
+    world::{WorldSnapshot, WorldState},
     Result,
     InitializationOptions,
 };
-use ra_prof::profile;
+
+const THREADPOOL_SIZE: usize = 8;
+const MAX_IN_FLIGHT_LIBS: usize = THREADPOOL_SIZE - 3;
 
 #[derive(Debug, Fail)]
 #[fail(display = "Language Server request failed with {}. ({})", code, message)]
@@ -39,34 +45,12 @@ impl LspError {
     }
 }
 
-#[derive(Debug)]
-enum Task {
-    Respond(RawResponse),
-    Notify(RawNotification),
-}
-
-struct PendingRequest {
-    received: Instant,
-    method: String,
-}
-
-impl From<(u64, PendingRequest)> for CompletedRequest {
-    fn from((id, pending): (u64, PendingRequest)) -> CompletedRequest {
-        CompletedRequest { id, method: pending.method, duration: pending.received.elapsed() }
-    }
-}
-
-const THREADPOOL_SIZE: usize = 8;
-
 pub fn main_loop(
     ws_roots: Vec<PathBuf>,
     options: InitializationOptions,
     msg_receiver: &Receiver<RawMessage>,
     msg_sender: &Sender<RawMessage>,
 ) -> Result<()> {
-    let pool = ThreadPool::new(THREADPOOL_SIZE);
-    let (task_sender, task_receiver) = unbounded::<Task>();
-
     // FIXME: support dynamic workspace loading.
     let workspaces = {
         let ws_worker = workspace_loader();
@@ -89,12 +73,13 @@ pub fn main_loop(
         loaded_workspaces
     };
 
-    let mut state = ServerWorldState::new(ws_roots, workspaces);
+    let mut state = WorldState::new(ws_roots, workspaces);
 
-    log::info!("server initialized, serving requests");
+    let pool = ThreadPool::new(THREADPOOL_SIZE);
+    let (task_sender, task_receiver) = unbounded::<Task>();
+    let mut pending_requests = PendingRequests::default();
 
-    let mut pending_requests = FxHashMap::default();
-    let mut subs = Subscriptions::new();
+    log::info!("server initialized, serving requests");
     let main_res = main_loop_inner(
         options,
         &pool,
@@ -104,7 +89,6 @@ pub fn main_loop(
         task_receiver.clone(),
         &mut state,
         &mut pending_requests,
-        &mut subs,
     );
 
     log::info!("waiting for tasks to finish...");
@@ -122,6 +106,12 @@ pub fn main_loop(
     main_res
 }
 
+#[derive(Debug)]
+enum Task {
+    Respond(RawResponse),
+    Notify(RawNotification),
+}
+
 enum Event {
     Msg(RawMessage),
     Task(Task),
@@ -171,11 +161,11 @@ fn main_loop_inner(
     msg_receiver: &Receiver<RawMessage>,
     task_sender: Sender<Task>,
     task_receiver: Receiver<Task>,
-    state: &mut ServerWorldState,
-    pending_requests: &mut FxHashMap<u64, PendingRequest>,
-    subs: &mut Subscriptions,
+    state: &mut WorldState,
+    pending_requests: &mut PendingRequests,
 ) -> Result<()> {
-    // We try not to index more than THREADPOOL_SIZE - 3 libraries at the same
+    let mut subs = Subscriptions::default();
+    // We try not to index more than MAX_IN_FLIGHT_LIBS libraries at the same
     // time to always have a thread ready to react to input.
     let mut in_flight_libraries = 0;
     let mut pending_libraries = Vec::new();
@@ -196,15 +186,16 @@ fn main_loop_inner(
             },
             recv(libdata_receiver) -> data => Event::Lib(data.unwrap())
         };
-        // NOTE: don't count blocking select! call as a loop-turn time
-        let _p = profile("main_loop_inner/loop-turn");
         let loop_start = Instant::now();
 
+        // NOTE: don't count blocking select! call as a loop-turn time
+        let _p = profile("main_loop_inner/loop-turn");
         log::info!("loop turn = {:?}", event);
         let queue_count = pool.queued_count();
         if queue_count > 0 {
             log::info!("queued count = {}", queue_count);
         }
+
         let mut state_changed = false;
         match event {
             Event::Task(task) => {
@@ -226,37 +217,18 @@ fn main_loop_inner(
                         Some(req) => req,
                         None => return Ok(()),
                     };
-                    match req.cast::<req::CollectGarbage>() {
-                        Ok((id, ())) => {
-                            state.collect_garbage();
-                            let resp = RawResponse::ok::<req::CollectGarbage>(id, &());
-                            msg_sender.send(resp.into()).unwrap()
-                        }
-                        Err(req) => {
-                            match on_request(
-                                state,
-                                pending_requests,
-                                pool,
-                                &task_sender,
-                                loop_start,
-                                req,
-                            )? {
-                                None => (),
-                                Some(req) => {
-                                    log::error!("unknown request: {:?}", req);
-                                    let resp = RawResponse::err(
-                                        req.id,
-                                        ErrorCode::MethodNotFound as i32,
-                                        "unknown request".to_string(),
-                                    );
-                                    msg_sender.send(resp.into()).unwrap()
-                                }
-                            }
-                        }
-                    }
+                    on_request(
+                        state,
+                        pending_requests,
+                        pool,
+                        &task_sender,
+                        msg_sender,
+                        loop_start,
+                        req,
+                    )?
                 }
                 RawMessage::Notification(not) => {
-                    on_notification(msg_sender, state, pending_requests, subs, not)?;
+                    on_notification(msg_sender, state, pending_requests, &mut subs, not)?;
                     state_changed = true;
                 }
                 RawMessage::Response(resp) => log::error!("unexpected response: {:?}", resp),
@@ -264,7 +236,7 @@ fn main_loop_inner(
         };
 
         pending_libraries.extend(state.process_changes());
-        while in_flight_libraries < THREADPOOL_SIZE - 3 && !pending_libraries.is_empty() {
+        while in_flight_libraries < MAX_IN_FLIGHT_LIBS && !pending_libraries.is_empty() {
             let (root, files) = pending_libraries.pop().unwrap();
             in_flight_libraries += 1;
             let sender = libdata_sender.clone();
@@ -305,13 +277,12 @@ fn main_loop_inner(
 fn on_task(
     task: Task,
     msg_sender: &Sender<RawMessage>,
-    pending_requests: &mut FxHashMap<u64, PendingRequest>,
-    state: &mut ServerWorldState,
+    pending_requests: &mut PendingRequests,
+    state: &mut WorldState,
 ) {
     match task {
         Task::Respond(response) => {
-            if let Some(pending) = pending_requests.remove(&response.id) {
-                let completed = CompletedRequest::from((response.id, pending));
+            if let Some(completed) = pending_requests.finish(response.id) {
                 log::info!("handled req#{} in {:?}", completed.id, completed.duration);
                 state.complete_request(completed);
                 msg_sender.send(response.into()).unwrap();
@@ -324,23 +295,36 @@ fn on_task(
 }
 
 fn on_request(
-    world: &mut ServerWorldState,
-    pending_requests: &mut FxHashMap<u64, PendingRequest>,
+    world: &mut WorldState,
+    pending_requests: &mut PendingRequests,
     pool: &ThreadPool,
     sender: &Sender<Task>,
+    msg_sender: &Sender<RawMessage>,
     request_received: Instant,
     req: RawRequest,
-) -> Result<Option<RawRequest>> {
-    let method = req.method.clone();
-    let mut pool_dispatcher = PoolDispatcher { req: Some(req), res: None, pool, world, sender };
-    let req = pool_dispatcher
+) -> Result<()> {
+    let mut pool_dispatcher = PoolDispatcher {
+        req: Some(req),
+        pool,
+        world,
+        sender,
+        msg_sender,
+        pending_requests,
+        request_received,
+    };
+    pool_dispatcher
+        .on_sync::<req::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))?
+        .on_sync::<req::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
+        .on_sync::<req::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
+        .on_sync::<req::SelectionRangeRequest>(|s, p| {
+            handlers::handle_selection_range(s.snapshot(), p)
+        })?
+        .on_sync::<req::FindMatchingBrace>(|s, p| {
+            handlers::handle_find_matching_brace(s.snapshot(), p)
+        })?
         .on::<req::AnalyzerStatus>(handlers::handle_analyzer_status)?
         .on::<req::SyntaxTree>(handlers::handle_syntax_tree)?
         .on::<req::ExtendSelection>(handlers::handle_extend_selection)?
-        .on::<req::SelectionRangeRequest>(handlers::handle_selection_range)?
-        .on::<req::FindMatchingBrace>(handlers::handle_find_matching_brace)?
-        .on::<req::JoinLines>(handlers::handle_join_lines)?
-        .on::<req::OnEnter>(handlers::handle_on_enter)?
         .on::<req::OnTypeFormatting>(handlers::handle_on_type_formatting)?
         .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)?
         .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
@@ -363,21 +347,13 @@ fn on_request(
         .on::<req::Formatting>(handlers::handle_formatting)?
         .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)?
         .finish();
-    match req {
-        Ok(id) => {
-            let prev =
-                pending_requests.insert(id, PendingRequest { method, received: request_received });
-            assert!(prev.is_none(), "duplicate request: {}", id);
-            Ok(None)
-        }
-        Err(req) => Ok(Some(req)),
-    }
+    Ok(())
 }
 
 fn on_notification(
     msg_sender: &Sender<RawMessage>,
-    state: &mut ServerWorldState,
-    pending_requests: &mut FxHashMap<u64, PendingRequest>,
+    state: &mut WorldState,
+    pending_requests: &mut PendingRequests,
     subs: &mut Subscriptions,
     not: RawNotification,
 ) -> Result<()> {
@@ -389,7 +365,7 @@ fn on_notification(
                     panic!("string id's not supported: {:?}", id);
                 }
             };
-            if pending_requests.remove(&id).is_some() {
+            if pending_requests.cancel(id) {
                 let response = RawResponse::err(
                     id,
                     ErrorCode::RequestCanceled as i32,
@@ -445,91 +421,143 @@ fn on_notification(
 
 struct PoolDispatcher<'a> {
     req: Option<RawRequest>,
-    res: Option<u64>,
     pool: &'a ThreadPool,
-    world: &'a mut ServerWorldState,
+    world: &'a mut WorldState,
+    pending_requests: &'a mut PendingRequests,
+    msg_sender: &'a Sender<RawMessage>,
     sender: &'a Sender<Task>,
+    request_received: Instant,
 }
 
 impl<'a> PoolDispatcher<'a> {
-    fn on<R>(&mut self, f: fn(ServerWorld, R::Params) -> Result<R::Result>) -> Result<&mut Self>
+    /// Dispatches the request onto the current thread
+    fn on_sync<R>(
+        &mut self,
+        f: fn(&mut WorldState, R::Params) -> Result<R::Result>,
+    ) -> Result<&mut Self>
     where
         R: req::Request + 'static,
         R::Params: DeserializeOwned + Send + 'static,
         R::Result: Serialize + 'static,
     {
-        let req = match self.req.take() {
-            None => return Ok(self),
-            Some(req) => req,
+        let (id, params) = match self.parse::<R>() {
+            Some(it) => it,
+            None => {
+                return Ok(self);
+            }
         };
-        match req.cast::<R>() {
-            Ok((id, params)) => {
-                // Real time requests block user typing, so we should react quickly to them.
-                // Currently this means that we try to cancel background jobs if we don't have
-                // a spare thread.
-                let is_real_time = TypeId::of::<R>() == TypeId::of::<req::JoinLines>()
-                    || TypeId::of::<R>() == TypeId::of::<req::OnEnter>();
-                if self.pool.queued_count() > 0 && is_real_time {
-                    self.world.cancel_requests();
-                }
+        let result = f(self.world, params);
+        let task = result_to_task::<R>(id, result);
+        on_task(task, self.msg_sender, self.pending_requests, self.world);
+        Ok(self)
+    }
 
-                let world = self.world.snapshot();
-                let sender = self.sender.clone();
-                self.pool.execute(move || {
-                    let response = match f(world, params) {
-                        Ok(resp) => RawResponse::ok::<R>(id, &resp),
-                        Err(e) => match e.downcast::<LspError>() {
-                            Ok(lsp_error) => {
-                                RawResponse::err(id, lsp_error.code, lsp_error.message)
-                            }
-                            Err(e) => {
-                                if is_canceled(&e) {
-                                    // FIXME: When https://github.com/Microsoft/vscode-languageserver-node/issues/457
-                                    // gets fixed, we can return the proper response.
-                                    // This works around the issue where "content modified" error would continuously
-                                    // show an message pop-up in VsCode
-                                    // RawResponse::err(
-                                    //     id,
-                                    //     ErrorCode::ContentModified as i32,
-                                    //     "content modified".to_string(),
-                                    // )
-                                    RawResponse {
-                                        id,
-                                        result: Some(serde_json::to_value(&()).unwrap()),
-                                        error: None,
-                                    }
-                                } else {
-                                    RawResponse::err(
-                                        id,
-                                        ErrorCode::InternalError as i32,
-                                        format!("{}\n{}", e, e.backtrace()),
-                                    )
-                                }
-                            }
-                        },
-                    };
-                    let task = Task::Respond(response);
-                    sender.send(task).unwrap();
-                });
-                self.res = Some(id);
+    /// Dispatches the request onto thread pool
+    fn on<R>(&mut self, f: fn(WorldSnapshot, R::Params) -> Result<R::Result>) -> Result<&mut Self>
+    where
+        R: req::Request + 'static,
+        R::Params: DeserializeOwned + Send + 'static,
+        R::Result: Serialize + 'static,
+    {
+        let (id, params) = match self.parse::<R>() {
+            Some(it) => it,
+            None => {
+                return Ok(self);
             }
-            Err(req) => self.req = Some(req),
-        }
+        };
+
+        self.pool.execute({
+            let world = self.world.snapshot();
+            let sender = self.sender.clone();
+            move || {
+                let result = f(world, params);
+                let task = result_to_task::<R>(id, result);
+                sender.send(task).unwrap();
+            }
+        });
+
         Ok(self)
     }
 
-    fn finish(&mut self) -> std::result::Result<u64, RawRequest> {
-        match (self.res.take(), self.req.take()) {
-            (Some(res), None) => Ok(res),
-            (None, Some(req)) => Err(req),
-            _ => unreachable!(),
+    fn parse<R>(&mut self) -> Option<(u64, R::Params)>
+    where
+        R: req::Request + 'static,
+        R::Params: DeserializeOwned + Send + 'static,
+    {
+        let req = self.req.take()?;
+        let (id, params) = match req.cast::<R>() {
+            Ok(it) => it,
+            Err(req) => {
+                self.req = Some(req);
+                return None;
+            }
+        };
+        self.pending_requests.start(PendingRequest {
+            id,
+            method: R::METHOD.to_string(),
+            received: self.request_received,
+        });
+        Some((id, params))
+    }
+
+    fn finish(&mut self) {
+        match self.req.take() {
+            None => (),
+            Some(req) => {
+                log::error!("unknown request: {:?}", req);
+                let resp = RawResponse::err(
+                    req.id,
+                    ErrorCode::MethodNotFound as i32,
+                    "unknown request".to_string(),
+                );
+                self.msg_sender.send(resp.into()).unwrap();
+            }
         }
     }
 }
 
+fn result_to_task<R>(id: u64, result: Result<R::Result>) -> Task
+where
+    R: req::Request + 'static,
+    R::Params: DeserializeOwned + Send + 'static,
+    R::Result: Serialize + 'static,
+{
+    let response = match result {
+        Ok(resp) => RawResponse::ok::<R>(id, &resp),
+        Err(e) => match e.downcast::<LspError>() {
+            Ok(lsp_error) => RawResponse::err(id, lsp_error.code, lsp_error.message),
+            Err(e) => {
+                if is_canceled(&e) {
+                    // FIXME: When https://github.com/Microsoft/vscode-languageserver-node/issues/457
+                    // gets fixed, we can return the proper response.
+                    // This works around the issue where "content modified" error would continuously
+                    // show an message pop-up in VsCode
+                    // RawResponse::err(
+                    //     id,
+                    //     ErrorCode::ContentModified as i32,
+                    //     "content modified".to_string(),
+                    // )
+                    RawResponse {
+                        id,
+                        result: Some(serde_json::to_value(&()).unwrap()),
+                        error: None,
+                    }
+                } else {
+                    RawResponse::err(
+                        id,
+                        ErrorCode::InternalError as i32,
+                        format!("{}\n{}", e, e.backtrace()),
+                    )
+                }
+            }
+        },
+    };
+    Task::Respond(response)
+}
+
 fn update_file_notifications_on_threadpool(
     pool: &ThreadPool,
-    world: ServerWorld,
+    world: WorldSnapshot,
     publish_decorations: bool,
     sender: Sender<Task>,
     subscriptions: Vec<FileId>,
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 0ebfd641d..6373240d5 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -24,22 +24,22 @@ use crate::{
     cargo_target_spec::{runnable_args, CargoTargetSpec},
     conv::{to_location, to_location_link, Conv, ConvWith, MapConvWith, TryConvWith},
     req::{self, Decoration},
-    server_world::ServerWorld,
+    world::WorldSnapshot,
     LspError, Result,
 };
 
-pub fn handle_analyzer_status(world: ServerWorld, _: ()) -> Result<String> {
+pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
     let mut buf = world.status();
     writeln!(buf, "\n\nrequests:").unwrap();
-    let requests = world.latest_completed_requests.read();
-    for (idx, r) in requests.iter().enumerate() {
-        let current = if idx == world.request_idx { "*" } else { " " };
-        writeln!(buf, "{:4}{}{:<36}{}ms", r.id, current, r.method, r.duration.as_millis()).unwrap();
+    let requests = world.latest_requests.read();
+    for (is_last, r) in requests.iter() {
+        let mark = if is_last { "*" } else { " " };
+        writeln!(buf, "{}{:4} {:<36}{}ms", mark, r.id, r.method, r.duration.as_millis()).unwrap();
     }
     Ok(buf)
 }
 
-pub fn handle_syntax_tree(world: ServerWorld, params: req::SyntaxTreeParams) -> Result<String> {
+pub fn handle_syntax_tree(world: WorldSnapshot, params: req::SyntaxTreeParams) -> Result<String> {
     let id = params.text_document.try_conv_with(&world)?;
     let line_index = world.analysis().file_line_index(id);
     let text_range = params.range.map(|p| p.conv_with(&line_index));
@@ -49,7 +49,7 @@ pub fn handle_syntax_tree(world: ServerWorld, params: req::SyntaxTreeParams) ->
 
 // FIXME: drop this API
 pub fn handle_extend_selection(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::ExtendSelectionParams,
 ) -> Result<req::ExtendSelectionResult> {
     log::error!(
@@ -69,7 +69,7 @@ pub fn handle_extend_selection(
 }
 
 pub fn handle_selection_range(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::SelectionRangeParams,
 ) -> Result<Vec<req::SelectionRange>> {
     let _p = profile("handle_selection_range");
@@ -110,7 +110,7 @@ pub fn handle_selection_range(
 }
 
 pub fn handle_find_matching_brace(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::FindMatchingBraceParams,
 ) -> Result<Vec<Position>> {
     let _p = profile("handle_find_matching_brace");
@@ -129,7 +129,7 @@ pub fn handle_find_matching_brace(
 }
 
 pub fn handle_join_lines(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::JoinLinesParams,
 ) -> Result<req::SourceChange> {
     let _p = profile("handle_join_lines");
@@ -138,7 +138,7 @@ pub fn handle_join_lines(
 }
 
 pub fn handle_on_enter(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::SourceChange>> {
     let _p = profile("handle_on_enter");
@@ -150,7 +150,7 @@ pub fn handle_on_enter(
 }
 
 pub fn handle_on_type_formatting(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::DocumentOnTypeFormattingParams,
 ) -> Result<Option<Vec<TextEdit>>> {
     let _p = profile("handle_on_type_formatting");
@@ -181,7 +181,7 @@ pub fn handle_on_type_formatting(
 }
 
 pub fn handle_document_symbol(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::DocumentSymbolParams,
 ) -> Result<Option<req::DocumentSymbolResponse>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -219,7 +219,7 @@ pub fn handle_document_symbol(
 }
 
 pub fn handle_workspace_symbol(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::WorkspaceSymbolParams,
 ) -> Result<Option<Vec<SymbolInformation>>> {
     let all_symbols = params.query.contains('#');
@@ -245,7 +245,7 @@ pub fn handle_workspace_symbol(
 
     return Ok(Some(res));
 
-    fn exec_query(world: &ServerWorld, query: Query) -> Result<Vec<SymbolInformation>> {
+    fn exec_query(world: &WorldSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
         let mut res = Vec::new();
         for nav in world.analysis().symbol_search(query)? {
             let info = SymbolInformation {
@@ -262,7 +262,7 @@ pub fn handle_workspace_symbol(
 }
 
 pub fn handle_goto_definition(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoDefinitionResponse>> {
     let position = params.try_conv_with(&world)?;
@@ -282,7 +282,7 @@ pub fn handle_goto_definition(
 }
 
 pub fn handle_goto_implementation(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoImplementationResponse>> {
     let position = params.try_conv_with(&world)?;
@@ -302,7 +302,7 @@ pub fn handle_goto_implementation(
 }
 
 pub fn handle_goto_type_definition(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoTypeDefinitionResponse>> {
     let position = params.try_conv_with(&world)?;
@@ -322,7 +322,7 @@ pub fn handle_goto_type_definition(
 }
 
 pub fn handle_parent_module(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Vec<Location>> {
     let position = params.try_conv_with(&world)?;
@@ -335,7 +335,7 @@ pub fn handle_parent_module(
 }
 
 pub fn handle_runnables(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::RunnablesParams,
 ) -> Result<Vec<req::Runnable>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -396,7 +396,7 @@ pub fn handle_runnables(
 }
 
 pub fn handle_decorations(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: TextDocumentIdentifier,
 ) -> Result<Vec<Decoration>> {
     let file_id = params.try_conv_with(&world)?;
@@ -404,7 +404,7 @@ pub fn handle_decorations(
 }
 
 pub fn handle_completion(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::CompletionParams,
 ) -> Result<Option<req::CompletionResponse>> {
     let _p = profile("handle_completion");
@@ -447,7 +447,7 @@ pub fn handle_completion(
 }
 
 pub fn handle_folding_range(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: FoldingRangeParams,
 ) -> Result<Option<Vec<FoldingRange>>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -481,7 +481,7 @@ pub fn handle_folding_range(
 }
 
 pub fn handle_signature_help(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::SignatureHelp>> {
     let position = params.try_conv_with(&world)?;
@@ -500,7 +500,7 @@ pub fn handle_signature_help(
 }
 
 pub fn handle_hover(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<Hover>> {
     let position = params.try_conv_with(&world)?;
@@ -522,7 +522,7 @@ pub fn handle_hover(
 
 /// Test doc comment
 pub fn handle_prepare_rename(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<PrepareRenameResponse>> {
     let position = params.try_conv_with(&world)?;
@@ -543,7 +543,7 @@ pub fn handle_prepare_rename(
     Ok(Some(PrepareRenameResponse::Range(loc.range)))
 }
 
-pub fn handle_rename(world: ServerWorld, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
     let file_id = params.text_document.try_conv_with(&world)?;
     let line_index = world.analysis().file_line_index(file_id);
     let offset = params.position.conv_with(&line_index);
@@ -569,7 +569,7 @@ pub fn handle_rename(world: ServerWorld, params: RenameParams) -> Result<Option<
 }
 
 pub fn handle_references(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::ReferenceParams,
 ) -> Result<Option<Vec<Location>>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -597,7 +597,7 @@ pub fn handle_references(
 }
 
 pub fn handle_formatting(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: DocumentFormattingParams,
 ) -> Result<Option<Vec<TextEdit>>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -641,7 +641,7 @@ pub fn handle_formatting(
 }
 
 pub fn handle_code_action(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::CodeActionParams,
 ) -> Result<Option<CodeActionResponse>> {
     let _p = profile("handle_code_action");
@@ -704,7 +704,7 @@ pub fn handle_code_action(
 }
 
 pub fn handle_code_lens(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::CodeLensParams,
 ) -> Result<Option<Vec<CodeLens>>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -781,7 +781,7 @@ enum CodeLensResolveData {
     Impls(req::TextDocumentPositionParams),
 }
 
-pub fn handle_code_lens_resolve(world: ServerWorld, code_lens: CodeLens) -> Result<CodeLens> {
+pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> {
     let data = code_lens.data.unwrap();
     let resolve = serde_json::from_value(data)?;
     match resolve {
@@ -826,7 +826,7 @@ pub fn handle_code_lens_resolve(world: ServerWorld, code_lens: CodeLens) -> Resu
 }
 
 pub fn handle_document_highlight(
-    world: ServerWorld,
+    world: WorldSnapshot,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<Vec<DocumentHighlight>>> {
     let file_id = params.text_document.try_conv_with(&world)?;
@@ -845,7 +845,7 @@ pub fn handle_document_highlight(
 }
 
 pub fn publish_diagnostics(
-    world: &ServerWorld,
+    world: &WorldSnapshot,
     file_id: FileId,
 ) -> Result<req::PublishDiagnosticsParams> {
     let uri = world.file_id_to_uri(file_id)?;
@@ -867,14 +867,14 @@ pub fn publish_diagnostics(
 }
 
 pub fn publish_decorations(
-    world: &ServerWorld,
+    world: &WorldSnapshot,
     file_id: FileId,
 ) -> Result<req::PublishDecorationsParams> {
     let uri = world.file_id_to_uri(file_id)?;
     Ok(req::PublishDecorationsParams { uri, decorations: highlight(&world, file_id)? })
 }
 
-fn highlight(world: &ServerWorld, file_id: FileId) -> Result<Vec<Decoration>> {
+fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>> {
     let line_index = world.analysis().file_line_index(file_id);
     let res = world
         .analysis()
diff --git a/crates/ra_lsp_server/src/main_loop/pending_requests.rs b/crates/ra_lsp_server/src/main_loop/pending_requests.rs
new file mode 100644
index 000000000..741770e45
--- /dev/null
+++ b/crates/ra_lsp_server/src/main_loop/pending_requests.rs
@@ -0,0 +1,72 @@
+use std::time::{Duration, Instant};
+
+use rustc_hash::FxHashMap;
+
+#[derive(Debug)]
+pub struct CompletedRequest {
+    pub id: u64,
+    pub method: String,
+    pub duration: Duration,
+}
+
+#[derive(Debug)]
+pub(crate) struct PendingRequest {
+    pub(crate) id: u64,
+    pub(crate) method: String,
+    pub(crate) received: Instant,
+}
+
+impl From<PendingRequest> for CompletedRequest {
+    fn from(pending: PendingRequest) -> CompletedRequest {
+        CompletedRequest {
+            id: pending.id,
+            method: pending.method,
+            duration: pending.received.elapsed(),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct PendingRequests {
+    map: FxHashMap<u64, PendingRequest>,
+}
+
+impl PendingRequests {
+    pub(crate) fn start(&mut self, request: PendingRequest) {
+        let id = request.id;
+        let prev = self.map.insert(id, request);
+        assert!(prev.is_none(), "duplicate request with id {}", id);
+    }
+    pub(crate) fn cancel(&mut self, id: u64) -> bool {
+        self.map.remove(&id).is_some()
+    }
+    pub(crate) fn finish(&mut self, id: u64) -> Option<CompletedRequest> {
+        self.map.remove(&id).map(CompletedRequest::from)
+    }
+}
+
+const N_COMPLETED_REQUESTS: usize = 10;
+
+#[derive(Debug, Default)]
+pub struct LatestRequests {
+    // hand-rolling VecDeque here to print things in a nicer way
+    buf: [Option<CompletedRequest>; N_COMPLETED_REQUESTS],
+    idx: usize,
+}
+
+impl LatestRequests {
+    pub(crate) fn record(&mut self, request: CompletedRequest) {
+        // special case: don't track status request itself
+        if request.method == "rust-analyzer/analyzerStatus" {
+            return;
+        }
+        let idx = self.idx;
+        self.buf[idx] = Some(request);
+        self.idx = (idx + 1) % N_COMPLETED_REQUESTS;
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (bool, &CompletedRequest)> {
+        let idx = self.idx;
+        self.buf.iter().enumerate().filter_map(move |(i, req)| Some((i == idx, req.as_ref()?)))
+    }
+}
diff --git a/crates/ra_lsp_server/src/main_loop/subscriptions.rs b/crates/ra_lsp_server/src/main_loop/subscriptions.rs
index 11bd952d9..470bc1205 100644
--- a/crates/ra_lsp_server/src/main_loop/subscriptions.rs
+++ b/crates/ra_lsp_server/src/main_loop/subscriptions.rs
@@ -1,21 +1,19 @@
 use ra_ide_api::FileId;
 use rustc_hash::FxHashSet;
 
-pub struct Subscriptions {
+#[derive(Default)]
+pub(crate) struct Subscriptions {
     subs: FxHashSet<FileId>,
 }
 
 impl Subscriptions {
-    pub fn new() -> Subscriptions {
-        Subscriptions { subs: FxHashSet::default() }
-    }
-    pub fn add_sub(&mut self, file_id: FileId) {
+    pub(crate) fn add_sub(&mut self, file_id: FileId) {
         self.subs.insert(file_id);
     }
-    pub fn remove_sub(&mut self, file_id: FileId) {
+    pub(crate) fn remove_sub(&mut self, file_id: FileId) {
         self.subs.remove(&file_id);
     }
-    pub fn subscriptions(&self) -> Vec<FileId> {
+    pub(crate) fn subscriptions(&self) -> Vec<FileId> {
         self.subs.iter().cloned().collect()
     }
 }
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/world.rs
index 7eb4d3e56..e0d2f6306 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -1,7 +1,6 @@
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
-    time::Duration,
 };
 
 use lsp_types::Url;
@@ -16,43 +15,38 @@ use failure::{Error, format_err};
 use gen_lsp_server::ErrorCode;
 
 use crate::{
+    main_loop::pending_requests::{CompletedRequest, LatestRequests},
     project_model::ProjectWorkspace,
     vfs_filter::IncludeRustFiles,
     Result,
     LspError,
 };
 
+/// `WorldState` is the primary mutable state of the language server
+///
+/// The most interesting components are `vfs`, which stores a consistent
+/// snapshot of the file systems, and `analysis_host`, which stores our
+/// incremental salsa database.
 #[derive(Debug)]
-pub struct ServerWorldState {
+pub struct WorldState {
     pub roots_to_scan: usize,
     pub roots: Vec<PathBuf>,
     pub workspaces: Arc<Vec<ProjectWorkspace>>,
     pub analysis_host: AnalysisHost,
     pub vfs: Arc<RwLock<Vfs>>,
-    // hand-rolling VecDeque here to print things in a nicer way
-    pub latest_completed_requests: Arc<RwLock<[CompletedRequest; N_COMPLETED_REQUESTS]>>,
-    pub request_idx: usize,
+    pub latest_requests: Arc<RwLock<LatestRequests>>,
 }
 
-const N_COMPLETED_REQUESTS: usize = 10;
-
-pub struct ServerWorld {
+/// An immutable snapshot of the world's state at a point in time.
+pub struct WorldSnapshot {
     pub workspaces: Arc<Vec<ProjectWorkspace>>,
     pub analysis: Analysis,
     pub vfs: Arc<RwLock<Vfs>>,
-    pub latest_completed_requests: Arc<RwLock<[CompletedRequest; N_COMPLETED_REQUESTS]>>,
-    pub request_idx: usize,
-}
-
-#[derive(Debug, Default)]
-pub struct CompletedRequest {
-    pub id: u64,
-    pub method: String,
-    pub duration: Duration,
+    pub latest_requests: Arc<RwLock<LatestRequests>>,
 }
 
-impl ServerWorldState {
-    pub fn new(folder_roots: Vec<PathBuf>, workspaces: Vec<ProjectWorkspace>) -> ServerWorldState {
+impl WorldState {
+    pub fn new(folder_roots: Vec<PathBuf>, workspaces: Vec<ProjectWorkspace>) -> WorldState {
         let mut change = AnalysisChange::new();
 
         let mut roots = Vec::new();
@@ -82,14 +76,13 @@ impl ServerWorldState {
 
         let mut analysis_host = AnalysisHost::default();
         analysis_host.apply_change(change);
-        ServerWorldState {
+        WorldState {
             roots_to_scan,
             roots: folder_roots,
             workspaces: Arc::new(workspaces),
             analysis_host,
             vfs: Arc::new(RwLock::new(vfs)),
-            latest_completed_requests: Default::default(),
-            request_idx: 0,
+            latest_requests: Default::default(),
         }
     }
 
@@ -149,17 +142,12 @@ impl ServerWorldState {
         self.analysis_host.apply_change(change);
     }
 
-    pub fn cancel_requests(&mut self) {
-        self.analysis_host.apply_change(AnalysisChange::new());
-    }
-
-    pub fn snapshot(&self) -> ServerWorld {
-        ServerWorld {
+    pub fn snapshot(&self) -> WorldSnapshot {
+        WorldSnapshot {
             workspaces: Arc::clone(&self.workspaces),
             analysis: self.analysis_host.analysis(),
             vfs: Arc::clone(&self.vfs),
-            latest_completed_requests: Arc::clone(&self.latest_completed_requests),
-            request_idx: self.request_idx.checked_sub(1).unwrap_or(N_COMPLETED_REQUESTS - 1),
+            latest_requests: Arc::clone(&self.latest_requests),
         }
     }
 
@@ -172,17 +160,11 @@ impl ServerWorldState {
     }
 
     pub fn complete_request(&mut self, request: CompletedRequest) {
-        // special case: don't track status request itself
-        if request.method == "rust-analyzer/analyzerStatus" {
-            return;
-        }
-        let idx = self.request_idx;
-        self.latest_completed_requests.write()[idx] = request;
-        self.request_idx = (idx + 1) % N_COMPLETED_REQUESTS;
+        self.latest_requests.write().record(request)
     }
 }
 
-impl ServerWorld {
+impl WorldSnapshot {
     pub fn analysis(&self) -> &Analysis {
         &self.analysis
     }
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 031405879..e681b8e0b 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -76,17 +76,16 @@ pub fn profile(desc: &str) -> Profiler {
                 }
             };
         }
-
         if stack.starts.len() > stack.filter_data.depth {
             return Profiler { desc: None };
         }
-
-        if stack.filter_data.allowed.is_empty() || stack.filter_data.allowed.contains(desc) {
-            stack.starts.push(Instant::now());
-            Profiler { desc: Some(desc.to_string()) }
-        } else {
-            Profiler { desc: None }
+        let allowed = &stack.filter_data.allowed;
+        if stack.starts.is_empty() && !allowed.is_empty() && !allowed.contains(desc) {
+            return Profiler { desc: None };
         }
+
+        stack.starts.push(Instant::now());
+        Profiler { desc: Some(desc.to_string()) }
     })
 }