Struct RustAnalyzerClient 

pub struct RustAnalyzerClient { /* private fields */ }

Implementations

impl RustAnalyzerClient

pub fn new(workspace_root: PathBuf, settings: Value) -> Self

pub async fn start(&mut self) -> Result<()>

pub async fn open_document(&mut self, uri: &str, content: &str) -> Result<()>

Tells rust-analyzer about content, opening the document or updating it as needed.

An open document’s content belongs to us for as long as it stays open: rust-analyzer refuses to re-read one from disk, so an edit anyone else makes is invisible to it until this sends the new content along. Every request for a document that has been edited since it was opened – which, with an agent at the other end, is most of them – was answered from the content it had when it was first looked at.

pub async fn close_document(&mut self, uri: &str) -> Result<()>

Tells rust-analyzer to stop taking this document’s content from us.

What is on disk becomes the truth about it again, which for a file that is no longer there means it stops existing rather than lingering in rust-analyzer as it last was.

pub async fn open_document_uris(&self) -> Vec<String>

The documents rust-analyzer has been told about, by URI.

pub async fn shutdown(&mut self) -> Result<()>

Shuts rust-analyzer down, attempting the graceful LSP handshake first.

pub async fn force_kill(&mut self)

Kills rust-analyzer immediately, without the LSP shutdown handshake.

Meant for when a graceful Self::shutdown was aborted, so the process must not be left behind.

pub fn is_gone(&self) -> bool

Whether rust-analyzer is gone, i.e. its stdout has closed because it exited or is about to.

pub fn exit_status(&mut self) -> Option<ExitStatus>

The exit status of the rust-analyzer process, if it has exited.

impl RustAnalyzerClient

pub async fn hover( &mut self, uri: &str, line: u32, character: u32, ) -> Result<Value>

pub async fn definition( &mut self, uri: &str, line: u32, character: u32, ) -> Result<Value>

pub async fn references( &mut self, uri: &str, line: u32, character: u32, ) -> Result<Value>

pub async fn completion( &mut self, uri: &str, line: u32, character: u32, ) -> Result<Value>

pub async fn rename( &mut self, uri: &str, line: u32, character: u32, new_name: &str, ) -> Result<Value>

Asks what renaming the symbol at a position would take, without doing any of it.

pub async fn prepare_rename( &mut self, uri: &str, line: u32, character: u32, ) -> Result<Value>

The range of the symbol a rename at this position would be about.

Asked before a rename for two reasons: it says what is about to be renamed, which is worth reporting back, and when there is nothing renameable there it says so more precisely than the rename itself does.

pub async fn document_symbols(&mut self, uri: &str) -> Result<Value>

pub async fn formatting(&mut self, uri: &str) -> Result<Value>

pub async fn diagnostics(&mut self, uri: &str) -> Result<Value>

pub async fn fresh_diagnostics(&mut self, uri: &str) -> Result<FreshDiagnostics>

Diagnostics for uri from a cargo check that has seen the file as it is now.

The diagnostics rustc gives – the ones anyone actually wants – only ever arrive as the result of a check, and a check takes as long as it takes. Asking rust-analyzer for one and waiting for it to finish is the only way to answer with the code in front of us rather than whatever was last reported about it.

pub async fn wait_until_loaded(&self, timeout: Duration) -> bool

Waits until rust-analyzer has no loading left to do, giving up after timeout.

Worth doing before anything whose answer is only right once rust-analyzer has seen the whole workspace.

pub async fn workspace_diagnostics(&mut self) -> Result<Value>

pub async fn code_actions( &mut self, uri: &str, start_line: u32, start_char: u32, end_line: u32, end_char: u32, ) -> Result<Value>