lsp: explicitly drop locks in handle_input (#12276)

Piotr Osiewicz created 2 years ago

Due to lifetime extension rules, we were holding onto the request
handler map mutex during parsing of the request itself. This had no
grand repercussions; it only prevented registering a handler for next
request until parsing of the previous one was done.



Release Notes:

- N/A

Change summary

crates/lsp/src/lsp.rs | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)

Detailed changes

crates/lsp/src/lsp.rs

@@ -452,24 +452,27 @@ impl LanguageServer {
             }
 
             if let Ok(msg) = serde_json::from_slice::<AnyNotification>(&buffer) {
-                if let Some(handler) = notification_handlers.lock().get_mut(msg.method) {
+                let mut notification_handlers = notification_handlers.lock();
+                if let Some(handler) = notification_handlers.get_mut(msg.method) {
                     handler(
                         msg.id,
                         msg.params.map(|params| params.get()).unwrap_or("null"),
                         cx.clone(),
                     );
                 } else {
+                    drop(notification_handlers);
                     on_unhandled_notification(msg);
                 }
             } else if let Ok(AnyResponse {
                 id, error, result, ..
             }) = serde_json::from_slice(&buffer)
             {
+                let mut response_handlers = response_handlers.lock();
                 if let Some(handler) = response_handlers
-                    .lock()
                     .as_mut()
                     .and_then(|handlers| handlers.remove(&id))
                 {
+                    drop(response_handlers);
                     if let Some(error) = error {
                         handler(Err(error));
                     } else if let Some(result) = result {