[ty] Remove ConnectionInitializer (#19353)

## Summary

This PR removes the `ConnectionInitializer` and inlines the
`initialize_start` and `initialize_finish` calls.

The main benefit of this is that it will allow us to use
[`Connection::memory`](https://docs.rs/lsp-server/latest/lsp_server/struct.Connection.html#method.memory)
in the mock server. That method returns two `Connection` where one of
them will represent the client side connection and the other will be
sent to the `Server::new` call to be used by the server. This way the
mock client can send notifications and requests to mimic the editor.

## Test Plan

I tested out the initialization process and checked that the initialized
result contains the server capabilities and server info.

crates/ty_server/src/lib.rs

@@ -1,8 +1,11 @@
-use crate::server::{ConnectionInitializer, Server};
+use std::num::NonZeroUsize;
+
 use anyhow::Context;
+use lsp_server::Connection;
+
+use crate::server::Server;
 pub use document::{NotebookDocument, PositionEncoding, TextDocument};
 pub(crate) use session::{DocumentQuery, Session};
-use std::num::NonZeroUsize;
 
 mod document;
 mod logging;
@@ -25,7 +28,7 @@ pub fn run_server() -> anyhow::Result<()> {
         .unwrap_or(four)
         .min(four);
 
-    let (connection, io_threads) = ConnectionInitializer::stdio();
+    let (connection, io_threads) = Connection::stdio();
 
     let server_result = Server::new(worker_threads, connection)
         .context("Failed to start server")?

crates/ty_server/src/server.rs

@@ -6,9 +6,9 @@ use crate::session::{AllOptions, ClientOptions, DiagnosticMode, Session};
 use lsp_server::Connection;
 use lsp_types::{
     ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, HoverProviderCapability,
-    InlayHintOptions, InlayHintServerCapabilities, MessageType, SemanticTokensLegend,
-    SemanticTokensOptions, SemanticTokensServerCapabilities, ServerCapabilities,
-    SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind,
+    InitializeParams, InlayHintOptions, InlayHintServerCapabilities, MessageType,
+    SemanticTokensLegend, SemanticTokensOptions, SemanticTokensServerCapabilities,
+    ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind,
     TextDocumentSyncOptions, TypeDefinitionProviderCapability, Url, WorkDoneProgressOptions,
 };
 use std::num::NonZeroUsize;
@@ -16,14 +16,12 @@ use std::panic::PanicHookInfo;
 use std::sync::Arc;
 
 mod api;
-mod connection;
 mod main_loop;
 mod schedule;
 
 use crate::session::client::Client;
 pub(crate) use api::Error;
-pub(crate) use connection::{ConnectionInitializer, ConnectionSender};
-pub(crate) use main_loop::{Action, Event, MainLoopReceiver, MainLoopSender};
+pub(crate) use main_loop::{Action, ConnectionSender, Event, MainLoopReceiver, MainLoopSender};
 
 pub(crate) type Result<T> = std::result::Result<T, api::Error>;
 
@@ -37,11 +35,9 @@ pub(crate) struct Server {
 }
 
 impl Server {
-    pub(crate) fn new(
-        worker_threads: NonZeroUsize,
-        connection: ConnectionInitializer,
-    ) -> crate::Result<Self> {
-        let (id, init_params) = connection.initialize_start()?;
+    pub(crate) fn new(worker_threads: NonZeroUsize, connection: Connection) -> crate::Result<Self> {
+        let (id, init_value) = connection.initialize_start()?;
+        let init_params: InitializeParams = serde_json::from_value(init_value)?;
 
         let AllOptions {
             global: global_options,
@@ -59,8 +55,16 @@ impl Server {
 
         let version = ruff_db::program_version().unwrap_or("Unknown");
 
-        let connection =
-            connection.initialize_finish(id, &server_capabilities, crate::SERVER_NAME, version)?;
+        connection.initialize_finish(
+            id,
+            serde_json::json!({
+                "capabilities": server_capabilities,
+                "serverInfo": {
+                    "name": crate::SERVER_NAME,
+                    "version": version
+                }
+            }),
+        )?;
 
         // The number 32 was chosen arbitrarily. The main goal was to have enough capacity to queue
         // some responses before blocking.

crates/ty_server/src/server/connection.rs

@@ -1,49 +0,0 @@
-use lsp_server as lsp;
-
-pub(crate) type ConnectionSender = crossbeam::channel::Sender<lsp::Message>;
-
-/// A builder for `Connection` that handles LSP initialization.
-pub(crate) struct ConnectionInitializer {
-    connection: lsp::Connection,
-}
-
-impl ConnectionInitializer {
-    /// Create a new LSP server connection over stdin/stdout.
-    pub(crate) fn stdio() -> (Self, lsp::IoThreads) {
-        let (connection, threads) = lsp::Connection::stdio();
-        (Self { connection }, threads)
-    }
-
-    /// Starts the initialization process with the client by listening for an initialization request.
-    /// Returns a request ID that should be passed into `initialize_finish` later,
-    /// along with the initialization parameters that were provided.
-    pub(super) fn initialize_start(
-        &self,
-    ) -> crate::Result<(lsp::RequestId, lsp_types::InitializeParams)> {
-        let (id, params) = self.connection.initialize_start()?;
-        Ok((id, serde_json::from_value(params)?))
-    }
-
-    /// Finishes the initialization process with the client,
-    /// returning an initialized `Connection`.
-    pub(super) fn initialize_finish(
-        self,
-        id: lsp::RequestId,
-        server_capabilities: &lsp_types::ServerCapabilities,
-        name: &str,
-        version: &str,
-    ) -> crate::Result<lsp_server::Connection> {
-        self.connection.initialize_finish(
-            id,
-            serde_json::json!({
-                "capabilities": server_capabilities,
-                "serverInfo": {
-                    "name": name,
-                    "version": version
-                }
-            }),
-        )?;
-
-        Ok(self.connection)
-    }
-}

crates/ty_server/src/server/main_loop.rs

@@ -11,6 +11,7 @@ use lsp_types::{
 };
 use serde_json::Value;
 
+pub(crate) type ConnectionSender = crossbeam::channel::Sender<Message>;
 pub(crate) type MainLoopSender = crossbeam::channel::Sender<Event>;
 pub(crate) type MainLoopReceiver = crossbeam::channel::Receiver<Event>;