Support cancellation requests (#18627)

crates/ty_server/src/server/api.rs

@@ -331,7 +331,7 @@ where
         .with_failure_code(server::ErrorCode::InternalError)
 }
 
-/// Sends back a response to the server using a [`Responder`].
+/// Sends back a response to the server, but only if the request wasn't cancelled.
 fn respond<Req>(
     id: &RequestId,
     result: Result<<<Req as RequestHandler>::RequestType as Request>::Result>,

crates/ty_server/src/server/main_loop.rs

@@ -1,4 +1,3 @@
-use crate::Session;
 use crate::server::schedule::Scheduler;
 use crate::server::{Server, api};
 use crate::session::client::Client;
@@ -79,7 +78,7 @@ impl Server {
                                 .outgoing_mut()
                                 .complete(&response.id)
                             {
-                                handler(&self.session, response);
+                                handler(&client, response);
                             } else {
                                 tracing::error!(
                                     "Received a response with ID {}, which was not expected",
@@ -203,7 +202,7 @@ impl Server {
                     .unwrap(),
                 ),
             };
-            let response_handler = move |_session: &Session, ()| {
+            let response_handler = move |_: &Client, ()| {
                 tracing::info!("File watcher successfully registered");
             };
 

crates/ty_server/src/server/schedule/thread/pool.rs

@@ -51,7 +51,7 @@ impl Pool {
 
         let threads = usize::from(threads);
 
-        let (job_sender, job_receiver) = crossbeam::channel::bounded(std::cmp::max(threads * 2, 4));
+        let (job_sender, job_receiver) = crossbeam::channel::bounded(std::cmp::min(threads * 2, 4));
         let extant_tasks = Arc::new(AtomicUsize::new(0));
 
         let mut handles = Vec::with_capacity(threads);

crates/ty_server/src/session/client.rs

@@ -7,7 +7,7 @@ use serde_json::Value;
 use std::any::TypeId;
 use std::fmt::Display;
 
-pub(crate) type ClientResponseHandler = Box<dyn FnOnce(&Session, lsp_server::Response) + Send>;
+pub(crate) type ClientResponseHandler = Box<dyn FnOnce(&Client, lsp_server::Response) + Send>;
 
 #[derive(Debug)]
 pub(crate) struct Client {
@@ -44,53 +44,51 @@ impl Client {
         &self,
         session: &Session,
         params: R::Params,
-        response_handler: impl FnOnce(&Session, R::Result) + Send + 'static,
+        response_handler: impl FnOnce(&Client, R::Result) + Send + 'static,
     ) -> crate::Result<()>
     where
         R: lsp_types::request::Request,
     {
-        let response_handler = Box::new(
-            move |session: &Session, response: lsp_server::Response| {
-                let _span =
-                    tracing::debug_span!("client_response", id=%response.id, method = R::METHOD)
-                        .entered();
+        let response_handler = Box::new(move |client: &Client, response: lsp_server::Response| {
+            let _span =
+                tracing::debug_span!("client_response", id=%response.id, method = R::METHOD)
+                    .entered();
 
-                match (response.error, response.result) {
-                    (Some(err), _) => {
+            match (response.error, response.result) {
+                (Some(err), _) => {
+                    tracing::error!(
+                        "Got an error from the client (code {code}, method {method}): {message}",
+                        code = err.code,
+                        message = err.message,
+                        method = R::METHOD
+                    );
+                }
+                (None, Some(response)) => match serde_json::from_value(response) {
+                    Ok(response) => response_handler(client, response),
+                    Err(error) => {
                         tracing::error!(
-                            "Got an error from the client (code {code}, method {method}): {message}",
-                            code = err.code,
-                            message = err.message,
+                            "Failed to deserialize client response (method={method}): {error}",
                             method = R::METHOD
                         );
                     }
-                    (None, Some(response)) => match serde_json::from_value(response) {
-                        Ok(response) => response_handler(session, response),
-                        Err(error) => {
-                            tracing::error!(
-                                "Failed to deserialize client response (method={method}): {error}",
-                                method = R::METHOD
-                            );
-                        }
-                    },
-                    (None, None) => {
-                        if TypeId::of::<R::Result>() == TypeId::of::<()>() {
-                            // We can't call `response_handler(())` directly here, but
-                            // since we _know_ the type expected is `()`, we can use
-                            // `from_value(Value::Null)`. `R::Result` implements `DeserializeOwned`,
-                            // so this branch works in the general case but we'll only
-                            // hit it if the concrete type is `()`, so the `unwrap()` is safe here.
-                            response_handler(session, serde_json::from_value(Value::Null).unwrap());
-                        } else {
-                            tracing::error!(
-                                "Invalid client response: did not contain a result or error (method={method})",
-                                method = R::METHOD
-                            );
-                        }
+                },
+                (None, None) => {
+                    if TypeId::of::<R::Result>() == TypeId::of::<()>() {
+                        // We can't call `response_handler(())` directly here, but
+                        // since we _know_ the type expected is `()`, we can use
+                        // `from_value(Value::Null)`. `R::Result` implements `DeserializeOwned`,
+                        // so this branch works in the general case but we'll only
+                        // hit it if the concrete type is `()`, so the `unwrap()` is safe here.
+                        response_handler(client, serde_json::from_value(Value::Null).unwrap());
+                    } else {
+                        tracing::error!(
+                            "Invalid client response: did not contain a result or error (method={method})",
+                            method = R::METHOD
+                        );
                     }
                 }
-            },
-        );
+            }
+        });
 
         let id = session
             .request_queue()