File size: 5,652 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
use std::{path::PathBuf, process, sync::mpsc};
use lsp_server::Message;
/// An LSP client for Rust Analyzer (RA) that launches it as a subprocess.
pub struct RAClient {
/// Handle to the client
handle: process::Child,
sender: Option<mpsc::SyncSender<Message>>,
receiver: Option<mpsc::Receiver<Message>>,
}
impl RAClient {
/// Create a new LSP client for Rust Analyzer.
pub fn new() -> Self {
let stdin = process::Stdio::piped();
let stdout = process::Stdio::piped();
let stderr = process::Stdio::inherit();
let child = process::Command::new("rust-analyzer")
.stdin(stdin)
.stdout(stdout)
.stderr(stderr)
// .env("RA_LOG", "info")
.env("RUST_BACKTRACE", "1")
.spawn()
.expect("Failed to start RA LSP server");
Self {
handle: child,
sender: None,
receiver: None,
}
}
pub fn start(&mut self, folders: &[PathBuf]) {
let stdout = self.handle.stdout.take().unwrap();
let mut stdin = self.handle.stdin.take().unwrap();
let (writer_sender, writer_receiver) = mpsc::sync_channel::<Message>(0);
_ = std::thread::spawn(move || {
writer_receiver
.into_iter()
.try_for_each(|it| it.write(&mut stdin))
});
let (reader_sender, reader_receiver) = mpsc::sync_channel::<Message>(0);
_ = std::thread::spawn(move || {
let mut reader = std::io::BufReader::new(stdout);
while let Ok(Some(msg)) = Message::read(&mut reader) {
reader_sender
.send(msg)
.expect("receiver was dropped, failed to send a message");
}
});
self.sender = Some(writer_sender);
self.receiver = Some(reader_receiver);
let workspace_paths = folders
.iter()
.map(|p| std::fs::canonicalize(p).unwrap())
.map(|p| lsp_types::WorkspaceFolder {
name: p.file_name().unwrap().to_string_lossy().to_string(),
uri: lsp_types::Url::from_file_path(p).unwrap(),
})
.collect::<Vec<_>>();
_ = self.request(lsp_server::Request {
id: 1.into(),
method: "initialize".to_string(),
params: serde_json::to_value(lsp_types::InitializeParams {
workspace_folders: Some(workspace_paths),
process_id: Some(std::process::id()),
capabilities: lsp_types::ClientCapabilities {
workspace: Some(lsp_types::WorkspaceClientCapabilities {
workspace_folders: Some(true),
..Default::default()
}),
..Default::default()
},
work_done_progress_params: lsp_types::WorkDoneProgressParams {
work_done_token: Some(lsp_types::ProgressToken::String("prepare".to_string())),
},
// we use workspace_folders so root_path and root_uri can be
// empty
..Default::default()
})
.unwrap(),
});
self.notify(lsp_server::Notification {
method: "initialized".to_string(),
params: serde_json::to_value(lsp_types::InitializedParams {}).unwrap(),
});
}
/// Send an LSP request to the server. This returns an option
/// in the case of an error such as the server being shut down
/// from pressing `Ctrl+C`.
pub fn request(&mut self, message: lsp_server::Request) -> Option<lsp_server::Response> {
tracing::debug!("sending {:?}", message);
self.sender
.as_mut()
.unwrap()
.send(Message::Request(message))
.ok()?;
loop {
match self.receiver.as_mut().unwrap().recv() {
Ok(lsp_server::Message::Response(response)) => {
tracing::debug!("received {:?}", response);
return Some(response);
}
Ok(m) => tracing::trace!("unexpected message: {:?}", m),
Err(_) => {
tracing::trace!("error receiving message");
return None;
}
}
}
}
pub fn notify(&mut self, message: lsp_server::Notification) {
self.sender
.as_mut()
.unwrap()
.send(Message::Notification(message))
.expect("failed to send message");
}
}
impl Drop for RAClient {
fn drop(&mut self) {
if self.sender.is_some() {
let Some(resp) = self.request(lsp_server::Request {
id: 1.into(),
method: "shutdown".to_string(),
params: serde_json::to_value(()).unwrap(),
}) else {
return;
};
if resp.error.is_none() {
tracing::info!("shutting down RA LSP server");
self.notify(lsp_server::Notification {
method: "exit".to_string(),
params: serde_json::to_value(()).unwrap(),
});
self.handle
.wait()
.expect("failed to wait for RA LSP server");
tracing::info!("shut down RA LSP server");
} else {
tracing::error!("failed to shutdown RA LSP server: {:#?}", resp);
}
}
self.sender = None;
self.receiver = None;
}
}
|