Break out sender/req_queue into a Conn struct, make ReqQueue : Clone

Author: davidbarsky

Cargo.lock

@@ -37,7 +37,7 @@ debug = 0
 # chalk-derive = { path = "../chalk/chalk-derive" }
 # line-index = { path = "lib/line-index" }
 # la-arena = { path = "lib/la-arena" }
-# lsp-server = { path = "lib/lsp-server" }
+lsp-server = { path = "lib/lsp-server" }
 
 
 # ungrammar = { path = "../ungrammar" }

Cargo.toml

@@ -53,8 +53,7 @@ type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;
 /// Note that this struct has more than one impl in various modules!
 #[doc(alias = "GlobalMess")]
 pub(crate) struct GlobalState {
-    sender: Sender<lsp_server::Message>,
-    req_queue: ReqQueue,
+    pub(crate) conn: Conn,
 
     pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
     pub(crate) fmt_pool: Handle<TaskPool<Task>, Receiver<Task>>,
@@ -125,6 +124,11 @@ pub(crate) struct GlobalState {
         OpQueue<(), (Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
     pub(crate) fetch_proc_macros_queue: OpQueue<Vec<ProcMacroPaths>, bool>,
     pub(crate) prime_caches_queue: OpQueue,
+
+#[derive(Clone)]
+pub(crate) struct Conn {
+    pub(crate) sender: Sender<lsp_server::Message>,
+    req_queue: Arc<ReqQueue>,
 }
 
 /// An immutable snapshot of the world's state at a point in time.
@@ -145,6 +149,8 @@ impl std::panic::UnwindSafe for GlobalStateSnapshot {}
 
 impl GlobalState {
     pub(crate) fn new(sender: Sender<lsp_server::Message>, config: Config) -> GlobalState {
+        let conn = Conn { sender, req_queue: Arc::new(ReqQueue::default()) };
+
         let loader = {
             let (sender, receiver) = unbounded::<vfs::loader::Message>();
             let handle: vfs_notify::NotifyHandle =
@@ -170,8 +176,7 @@ impl GlobalState {
         }
         let (flycheck_sender, flycheck_receiver) = unbounded();
         let mut this = GlobalState {
-            sender,
-            req_queue: ReqQueue::default(),
+            conn: server,
             task_pool,
             fmt_pool,
             loader,
@@ -376,13 +381,13 @@ impl GlobalState {
         params: R::Params,
         handler: ReqHandler,
     ) {
-        let request = self.req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
-        self.send(request.into());
+        self.conn.send_request::<R>(params, handler);
     }
 
     pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
-        let handler = self
-            .req_queue
+        let req_queue = Arc::make_mut(&mut self.conn.req_queue);
+
+        let handler = req_queue
             .outgoing
             .complete(response.id.clone())
             .expect("received response for unknown request");
@@ -393,22 +398,20 @@ impl GlobalState {
         &self,
         params: N::Params,
     ) {
-        let not = lsp_server::Notification::new(N::METHOD.to_string(), params);
-        self.send(not.into());
+        self.conn.send_notification::<N>(params);
     }
 
     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));
+        self.conn.register_request(request, request_received);
     }
 
     pub(crate) fn respond(&mut self, response: lsp_server::Response) {
-        if let Some((method, start)) = self.req_queue.incoming.complete(response.id.clone()) {
+        let req_queue = Arc::make_mut(&mut self.conn.req_queue);
+        if let Some((method, start)) = req_queue.incoming.complete(response.id.clone()) {
             if let Some(err) = &response.error {
                 if err.message.starts_with("server panicked") {
                     self.poke_rust_analyzer_developer(format!("{}, check the log", err.message))
@@ -417,17 +420,51 @@ impl GlobalState {
 
             let duration = start.elapsed();
             tracing::debug!("handled {} - ({}) in {:0.2?}", method, response.id, duration);
-            self.send(response.into());
+            self.conn.send(response.into());
         }
     }
 
     pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
-        if let Some(response) = self.req_queue.incoming.cancel(request_id) {
+        self.conn.cancel(request_id);
+    }
+
+    pub(crate) fn is_completed(&self, request: &lsp_server::Request) -> bool {
+        self.conn.is_completed(&request)
+    }
+}
+
+impl Conn {
+    pub(crate) fn send_request<R: lsp_types::request::Request>(
+        &mut self,
+        params: R::Params,
+        handler: ReqHandler,
+    ) {
+        let req_queue = Arc::make_mut(&mut self.req_queue);
+        let request = req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
+        self.send(request.into());
+    }
+
+    pub(crate) fn send_notification<N: lsp_types::notification::Notification>(
+        &self,
+        params: N::Params,
+    ) {
+        let not = lsp_server::Notification::new(N::METHOD.to_string(), params);
+        self.send(not.into());
+    }
+
+    fn register_request(&mut self, request: &lsp_server::Request, request_received: Instant) {
+        let req_queue = Arc::make_mut(&mut self.req_queue);
+        req_queue.incoming.register(request.id.clone(), (request.method.clone(), request_received));
+    }
+
+    fn cancel(&mut self, request_id: lsp_server::RequestId) {
+        let req_queue = Arc::make_mut(&mut self.req_queue);
+        if let Some(response) = req_queue.incoming.cancel(request_id) {
             self.send(response.into());
         }
     }
 
-    pub(crate) fn is_completed(&self, request: &lsp_server::Request) -> bool {
+    fn is_completed(&self, request: &lsp_server::Request) -> bool {
         self.req_queue.incoming.is_completed(&request.id)
     }
 

crates/rust-analyzer/src/global_state.rs

@@ -212,6 +212,7 @@ impl Server {
                     .extract::<Value>(N::METHOD)
                     .expect("was not able to extract notification");
 
+                tracing::debug!(?actual, "got notification");
                 if let Some((expected_part, actual_part)) = find_mismatch(&expected, &actual) {
                     panic!(
                             "JSON mismatch\nExpected:\n{}\nWas:\n{}\nExpected part:\n{}\nActual part:\n{}\n",
@@ -221,6 +222,7 @@ impl Server {
                             to_string_pretty(actual_part).unwrap(),
                         );
                 } else {
+                    tracing::debug!("sucessfully matched notification");
                     return;
                 }
             } else {

crates/rust-analyzer/tests/slow-tests/support.rs

@@ -5,7 +5,7 @@ use serde::Serialize;
 use crate::{ErrorCode, Request, RequestId, Response, ResponseError};
 
 /// Manages the set of pending requests, both incoming and outgoing.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ReqQueue<I, O> {
     pub incoming: Incoming<I>,
     pub outgoing: Outgoing<O>,
@@ -20,12 +20,12 @@ impl<I, O> Default for ReqQueue<I, O> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Incoming<I> {
     pending: HashMap<RequestId, I>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Outgoing<O> {
     next_id: i32,
     pending: HashMap<RequestId, O>,