connection: Connection,

worker_threads: NonZeroUsize,

main_loop_receiver: MainLoopReceiver,

main_loop_sender: MainLoopSender,

session: Session,

pub fn new(

worker_threads: NonZeroUsize,

connection: Connection,

native_system: Arc<dyn System + 'static + Send + Sync + RefUnwindSafe>,

in_test: bool,

) -> crate::Result<Self> {

let (id, init_value) = connection.initialize_start()?;

let InitializeParams {

initialization_options,

capabilities: client_capabilities,

workspace_folders_initialize_params:

WorkspaceFoldersInitializeParams { workspace_folders },

client_info,

..

} = serde_json::from_value(init_value)

.context("Failed to deserialize initialization parameters")?;

let (initialization_options, deserialization_error) =

match InitializationOptions::from_value(initialization_options) {

Ok(options) => options,

Err(error) => {

connection.sender.send(Message::Response(Response::new_err(

id,

ErrorCode::InvalidParams as i32,

format!("Invalid initialization options: {error:#}"),

)))?;

return Err(error).context("Failed to deserialize initialization options");

}

};

if !in_test {

crate::logging::init_logging(

initialization_options.log_level.unwrap_or_default(),

initialization_options.log_file.as_deref(),

);

}

if let Some(error) = deserialization_error {

tracing::error!("Failed to deserialize initialization options: {error}");

}

tracing::debug!("Client info: {client_info:#?}");

tracing::debug!("Initialization options: {initialization_options:#?}");

let resolved_client_capabilities = ResolvedClientCapabilities::new(&client_capabilities);

tracing::debug!("Resolved client capabilities: {resolved_client_capabilities}");

let position_encoding = Self::find_best_position_encoding(&client_capabilities);

let server_capabilities =

server_capabilities(position_encoding, resolved_client_capabilities);

let version = ruff_db::program_version().unwrap_or("Unknown");

tracing::info!("Version: {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.

let (main_loop_sender, main_loop_receiver) = crossbeam::channel::bounded(32);

let client = Client::new(main_loop_sender.clone(), connection.sender.clone());

let unknown_options = &initialization_options.options.unknown;

if !unknown_options.is_empty() {

warn_about_unknown_options(&client, None, unknown_options);

}

// Get workspace URLs without settings - settings will come from workspace/configuration

let workspace_urls = workspace_folders

.and_then(|folders| {

if let WorkspaceFolders::WorkspaceFolderList(folders) = folders

&& !folders.is_empty()

{

Some(folders)

} else {

None

}

})

.map(|folders| {

folders

.into_iter()

.map(|folder| folder.uri)

.collect::<Vec<_>>()

})

.or_else(|| {

let current_dir = native_system

.current_directory()

.as_std_path()

.to_path_buf();

tracing::warn!(

"No workspace(s) were provided during initialization. \

current_dir.display()

);

let uri = Uri::from_file_path(current_dir).ok()?;

Some(vec![uri])

})

.ok_or_else(|| {

anyhow::anyhow!(

"Failed to get the current working directory while creating a \

)

})?;

Ok(Self {

connection,

worker_threads,

main_loop_receiver,

main_loop_sender,

session: Session::new(

resolved_client_capabilities,

position_encoding,

workspace_urls,

initialization_options,

native_system,

ClientName::from(client_info),

in_test,

)?,

})

}

pub fn run(mut self) -> crate::Result<()> {

let client = Client::new(

self.main_loop_sender.clone(),

self.connection.sender.clone(),

);

let _panic_hook = ServerPanicHookHandler::new(client);

spawn_main_loop(move || self.main_loop())?.join()

}

fn find_best_position_encoding(client_capabilities: &ClientCapabilities) -> PositionEncoding {

client_capabilities

.general

.as_ref()

.and_then(|general_capabilities| general_capabilities.position_encodings.as_ref())

.and_then(|encodings| {

encodings

.iter()

.filter_map(|encoding| PositionEncoding::try_from(encoding).ok())

.max() // this selects the highest priority position encoding

})

.unwrap_or_default()

}

hook: Option<PanicHook>,

// Hold on to the strong reference for as long as the panic hook is set.

_client: Arc<Client>,

fn new(client: Client) -> Self {

let hook = std::panic::take_hook();

let client = Arc::new(client);

// Use a weak reference to the client because it must be dropped when exiting or the

// io-threads join hangs forever (because client has a reference to the connection sender).

let hook_client = Arc::downgrade(&client);

// When we panic, try to notify the client.

std::panic::set_hook(Box::new(move |panic_info| {

use std::io::Write;

let backtrace = std::backtrace::Backtrace::force_capture();

tracing::error!("{panic_info}\n{backtrace}");

// we also need to print to stderr directly for when using `$logTrace` because

// the message won't be sent to the client.

// But don't use `eprintln` because `eprintln` itself may panic if the pipe is broken.

let mut stderr = std::io::stderr().lock();

writeln!(stderr, "{panic_info}\n{backtrace}").ok();

if let Some(client) = hook_client.upgrade() {

client.show_message(

"The ty language server exited with a panic. See the logs for more details.",

MessageType::Error,

);

}

}));

Self {

hook: Some(hook),

_client: client,

}

}

fn drop(&mut self) {

if std::thread::panicking() {

// Calling `std::panic::set_hook` while panicking results in a panic.

return;

}

if let Some(hook) = self.hook.take() {

std::panic::set_hook(hook);

}

}

use std::num::NonZeroUsize;

use std::sync::Arc;

use lsp_server::{Connection, ErrorCode, Message, Notification, Request};

use ruff_db::system::OsSystem;

use serde_json::{Value, json};

use super::Server;

use crate::system::WorkspaceTrust;

#[test]

fn malformed_trust_rejects_initialization() -> anyhow::Result<()> {

let (connection, client) = initialize_connection(&json!({

"untrustedWorkspace": "true",

"logLevel": "invalid"

}))?;

assert!(

Server::new(

NonZeroUsize::MIN,

connection,

Arc::new(OsSystem::default()),

true,

)

.is_err()

);

let Message::Response(response) = client.receiver.try_recv()? else {

anyhow::bail!("Expected an initialization error response");

};

assert_eq!(response.id, 1.into());

let error = response.response_result.unwrap_err();

assert_eq!(error.code, ErrorCode::InvalidParams as i32);

assert_eq!(

error.message,

"Invalid initialization options: Invalid `untrustedWorkspace` setting: \

);

Ok(())

}

#[test]

fn malformed_initialization_options_preserve_workspace_trust() -> anyhow::Result<()> {

let (connection, _client_connection) = initialize_connection(&json!({

"untrustedWorkspace": true,

"diagnosticMode": "invalid"

}))?;

let server = Server::new(

NonZeroUsize::MIN,

connection,

Arc::new(OsSystem::default()),

true,

)?;

assert_eq!(

server.session.initialization_options().workspace_trust,

WorkspaceTrust::Untrusted,

);

Ok(())

}

fn initialize_connection(

initialization_options: &Value,

) -> anyhow::Result<(Connection, Connection)> {

let (server, client) = Connection::memory();

client.sender.send(Message::Request(Request::new(

1.into(),

"initialize".into(),

json!({

"capabilities": {},

"initializationOptions": initialization_options

}),

)))?;

client.sender.send(Message::Notification(Notification::new(

"initialized".into(),

json!({}),

)))?;

Ok((server, client))

}