rust-analyzer

diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 64decc9e0d..10f45ddb25 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs

@@ -310,9 +310,10 @@ impl GlobalState {

let event_dbg_msg = format!("{event:?}");

tracing::debug!(?loop_start, ?event, "handle_event");

if tracing::enabled!(tracing::Level::TRACE) {

+ // tracing::debug!(?loop_start, ?event, "handle_event");

let task_queue_len = self.task_pool.handle.len();

if task_queue_len > 0 {

- tracing::trace!("task queue len: {}", task_queue_len);

+ tracing::info!("task queue len: {}", task_queue_len);

}

diff --git a/lib/lsp-server/Cargo.toml b/lib/lsp-server/Cargo.toml
index f56a0de616..4722619f4d 100644
--- a/lib/lsp-server/Cargo.toml
+++ b/lib/lsp-server/Cargo.toml

@@ -12,6 +12,7 @@ serde_json = "1.0.140"

serde = { version = "1.0.219" }

serde_derive = { version = "1.0.219" }

crossbeam-channel.workspace = true

+lsp-types = "=0.95"

[dev-dependencies]

lsp-types = "=0.95"

diff --git a/lib/lsp-server/src/error.rs b/lib/lsp-server/src/error.rs
index da55393339..572d651c65 100644
--- a/lib/lsp-server/src/error.rs
+++ b/lib/lsp-server/src/error.rs

@@ -30,6 +30,8 @@ impl fmt::Display for ProtocolError {

#[derive(Debug)]

pub enum ExtractError<T> {

+ /// Not found

+ NoResult,

/// The extracted message was of a different method than expected.

MethodMismatch(T),

/// Failed to deserialize the message.

@@ -40,6 +42,9 @@ impl std::error::Error for ExtractError<Request> {}

impl fmt::Display for ExtractError<Request> {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self {

+ ExtractError::NoResult => {

+ write!(f, "unfound")

+ }

ExtractError::MethodMismatch(req) => {

write!(f, "Method mismatch for request '{}'", req.method)

}

@@ -54,6 +59,9 @@ impl std::error::Error for ExtractError<Notification> {}

impl fmt::Display for ExtractError<Notification> {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self {

+ ExtractError::NoResult => {

+ write!(f, "unfound")

+ }

ExtractError::MethodMismatch(req) => {

write!(f, "Method mismatch for notification '{}'", req.method)

}

diff --git a/lib/lsp-server/src/lib.rs b/lib/lsp-server/src/lib.rs
index 315cb2d5c3..66ecbf8c33 100644
--- a/lib/lsp-server/src/lib.rs
+++ b/lib/lsp-server/src/lib.rs

@@ -6,12 +6,12 @@

#![warn(rust_2018_idioms, unused_lifetimes)]

#![allow(clippy::print_stdout, clippy::disallowed_types)]

-mod error;

-mod msg;

-mod req_queue;

-mod socket;

-mod stdio;

+#![feature(bool_to_result)]

+pub mod error;

+pub mod msg;

+pub mod req_queue;

+pub mod socket;

+pub mod stdio;

use std::{

io::{self, Stdin, Stdout},

diff --git a/lib/lsp-server/src/msg.rs b/lib/lsp-server/src/msg.rs
index eb8b6bbf04..5e91e33280 100644
--- a/lib/lsp-server/src/msg.rs
+++ b/lib/lsp-server/src/msg.rs

@@ -234,6 +234,12 @@ impl Response {

let error = ResponseError { code, message, data: None };

Response { id, result: None, error: Some(error) }

}

+ pub fn load<P: DeserializeOwned>(self) -> Result<P, ExtractError<Request>> {

+ self.result.ok_or(ExtractError::NoResult).and_then(|x| {

+ serde_json::from_value(x)

+ .map_err(|error| ExtractError::JsonError { method: "".into(), error })

+ })

+ }

}

impl Request {

@@ -265,6 +271,14 @@ impl Notification {

pub fn new(method: String, params: impl serde::Serialize) -> Notification {

Notification { method, params: serde_json::to_value(params).unwrap() }

}

+ pub fn load<T: lsp_types::notification::Notification>(

+ self,

+ ) -> Result<T::Params, ExtractError<Notification>> {

+ (self.method == T::METHOD).ok_or(ExtractError::NoResult).and_then(|()| {

+ serde_json::from_value(self.params)

+ .map_err(|e| ExtractError::JsonError { method: self.method, error: e })

+ })

+ }

pub fn extract<P: DeserializeOwned>(

self,

method: &str,

diff --git a/lib/lsp-server/src/socket.rs b/lib/lsp-server/src/socket.rs
index 793073d1f7..59d0dc7b0c 100644
--- a/lib/lsp-server/src/socket.rs
+++ b/lib/lsp-server/src/socket.rs

@@ -16,10 +16,7 @@ pub(crate) fn socket_transport(

) -> (Sender<Message>, Receiver<Message>, IoThreads) {

let (reader_receiver, reader) = make_reader(stream.try_clone().unwrap());

let (writer_sender, writer, messages_to_drop) = make_write(stream);

- let dropper = std::thread::spawn(move || {

- messages_to_drop.into_iter().for_each(drop);

- });

- let io_threads = make_io_threads(reader, writer, dropper);

+ let io_threads = make_io_threads(reader, writer);

(writer_sender, reader_receiver, io_threads)

}

diff --git a/lib/lsp-server/src/stdio.rs b/lib/lsp-server/src/stdio.rs
index 711c4e9907..d3789ce5c0 100644
--- a/lib/lsp-server/src/stdio.rs
+++ b/lib/lsp-server/src/stdio.rs

@@ -8,36 +8,29 @@ use log::debug;

use crossbeam_channel::{Receiver, Sender, bounded};

use crate::Message;

/// Creates an LSP connection via stdio.

-pub(crate) fn stdio_transport(

+pub fn stdio_transport(

mut read_from: impl Read + std::io::BufRead + Sync + Send + 'static,

mut write_to: impl Write + Sync + Send + 'static,

) -> (Sender<Message>, Receiver<Message>, IoThreads) {

- let (drop_sender, drop_receiver) = bounded::<Message>(0);

let (writer_sender, writer_receiver) = bounded::<Message>(0);

let writer = thread::Builder::new()

.name("LspServerWriter".to_owned())

.spawn(move || {

writer_receiver.into_iter().try_for_each(|it| {

+ debug!("sent message {it:#?}");

let result = it.write(&mut write_to);

- let _ = drop_sender.send(it);

result

})

.unwrap();

- let dropper = thread::Builder::new()

- .name("LspMessageDropper".to_owned())

- .spawn(move || drop_receiver.into_iter().for_each(drop))

- .unwrap();

let (reader_sender, reader_receiver) = bounded::<Message>(0);

let reader: thread::JoinHandle<Result<(), io::Error>> = thread::Builder::new()

.name("LspServerReader".to_owned())

.spawn(move || {

while let Some(msg) = Message::read(&mut read_from)? {

let is_exit = matches!(&msg, Message::Notification(n) if n.is_exit());

- debug!("sending message {msg:#?}");

+ debug!("received message {msg:#?}");

if let Err(e) = reader_sender.send(msg) {

return Err(io::Error::other(e));

}

@@ -49,7 +42,7 @@ pub(crate) fn stdio_transport(

Ok(())

})

.unwrap();

- let threads = IoThreads { reader, writer, dropper };

+ let threads = IoThreads { reader, writer };

(writer_sender, reader_receiver, threads)

}

@@ -57,15 +50,13 @@ pub(crate) fn stdio_transport(

pub(crate) fn make_io_threads(

reader: thread::JoinHandle<io::Result<()>>,

writer: thread::JoinHandle<io::Result<()>>,

- dropper: thread::JoinHandle<()>,

) -> IoThreads {

- IoThreads { reader, writer, dropper }

+ IoThreads { reader, writer }

}

pub struct IoThreads {

reader: thread::JoinHandle<io::Result<()>>,

writer: thread::JoinHandle<io::Result<()>>,

- dropper: thread::JoinHandle<()>,

}

impl IoThreads {

@@ -74,12 +65,6 @@ impl IoThreads {

Ok(r) => r?,

Err(err) => std::panic::panic_any(err),

}

- match self.dropper.join() {

- Ok(_) => (),

- Err(err) => {

- std::panic::panic_any(err);

- }

match self.writer.join() {

Ok(r) => r,

Err(err) => {