Struct slide_ls::SlideLS

pub struct SlideLS {
    client: Client,
    document_registry: Mutex<RefCell<HashMap<Url, ProgramInfo>>>,
    context: Mutex<RefCell<ProgramContext>>,
    client_caps: Mutex<RefCell<ClientCapabilities>>,
}

A slide language server.

Fields

client: Client

document_registry: Mutex<RefCell<HashMap<Url, ProgramInfo>>>

context: Mutex<RefCell<ProgramContext>>

client_caps: Mutex<RefCell<ClientCapabilities>>

Implementations

impl SlideLS

pub fn new(client: Client) -> Self

Creates a new language server given a server client.

pub fn capabilities() -> ServerCapabilities

Returns capabilities of the language server.

async fn change<'_>(&'_ self, doc: Url, text: String, version: Option<i64>)

fn close(&self, doc: &Url)

fn doc_registry(&self) -> MutexGuard<'_, RefCell<HashMap<Url, ProgramInfo>>>

fn get_program_info(&self, doc: &Url) -> MappedMutexGuard<'_, ProgramInfo>

fn context(&self) -> MappedMutexGuard<'_, ProgramContext>

fn client_caps(&self) -> MappedMutexGuard<'_, ClientCapabilities>

Trait Implementations

impl LanguageServer for SlideLS

fn initialize<'life0, 'async_trait>(
    &'life0 self,
    params: InitializeParams
) -> Pin<Box<dyn Future<Output = Result<InitializeResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The initialize request is the first request sent from the client to the server.

fn initialized<'life0, 'async_trait>(
    &'life0 self,
    _params: InitializedParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The initialized notification is sent from the client to the server after the client received the result of the initialize request but before the client sends anything else.

fn shutdown<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The shutdown request asks the server to gracefully shut down, but to not exit.

fn did_open<'life0, 'async_trait>(
    &'life0 self,
    params: DidOpenTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/didOpen notification is sent from the client to the server to signal that a new text document has been opened by the client.

fn did_change<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/didChange notification is sent from the client to the server to signal changes to a text document.

fn did_close<'life0, 'async_trait>(
    &'life0 self,
    params: DidCloseTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/didClose notification is sent from the client to the server when the document got closed in the client.

fn goto_definition<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/definition request asks the server for the definition location of a symbol at a given text document position.

fn hover<'life0, 'async_trait>(
    &'life0 self,
    params: HoverParams
) -> Pin<Box<dyn Future<Output = Result<Option<Hover>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/hover request asks the server for hover information at a given text document position.

fn references<'life0, 'async_trait>(
    &'life0 self,
    params: ReferenceParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Location>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/references request is sent from the client to the server to resolve project-wide references for the symbol denoted by the given text document position.

fn document_highlight<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentHighlightParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<DocumentHighlight>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/documentHighlight request is sent from the client to the server to resolve appropriate highlights for a given text document position.

#[must_use]fn did_change_workspace_folders<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeWorkspaceFoldersParams
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The workspace/didChangeWorkspaceFolders notification is sent from the client to the server to inform about workspace folder configuration changes.

#[must_use]fn did_change_configuration<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeConfigurationParams
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The workspace/didChangeConfiguration notification is sent from the client to the server to signal the change of configuration settings.

#[must_use]fn did_change_watched_files<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeWatchedFilesParams
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The workspace/didChangeWatchedFiles notification is sent from the client to the server when the client detects changes to files watched by the language client.

#[must_use]fn symbol<'life0, 'async_trait>(
    &'life0 self,
    params: WorkspaceSymbolParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<SymbolInformation>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The workspace/symbol request is sent from the client to the server to list project-wide symbols matching the given query string.

#[must_use]fn execute_command<'life0, 'async_trait>(
    &'life0 self,
    params: ExecuteCommandParams
) -> Pin<Box<dyn Future<Output = Result<Option<Value>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The workspace/executeCommand request is sent from the client to the server to trigger command execution on the server.

#[must_use]fn will_save<'life0, 'async_trait>(
    &'life0 self,
    params: WillSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/willSave notification is sent from the client to the server before the document is actually saved.

#[must_use]fn will_save_wait_until<'life0, 'async_trait>(
    &'life0 self,
    params: WillSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The [textDocument/willSaveWaitUntil] request is sent from the client to the server before the document is actually saved.

#[must_use]fn did_save<'life0, 'async_trait>(
    &'life0 self,
    params: DidSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/didSave notification is sent from the client to the server when the document was saved in the client.

#[must_use]fn completion<'life0, 'async_trait>(
    &'life0 self,
    params: CompletionParams
) -> Pin<Box<dyn Future<Output = Result<Option<CompletionResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/completion request is sent from the client to the server to compute completion items at a given cursor position.

#[must_use]fn completion_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: CompletionItem
) -> Pin<Box<dyn Future<Output = Result<CompletionItem, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The completionItem/resolve request is sent from the client to the server to resolve additional information for a given completion item.

#[must_use]fn signature_help<'life0, 'async_trait>(
    &'life0 self,
    params: SignatureHelpParams
) -> Pin<Box<dyn Future<Output = Result<Option<SignatureHelp>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/signatureHelp request is sent from the client to the server to request signature information at a given cursor position.

#[must_use]fn goto_declaration<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/declaration request asks the server for the declaration location of a symbol at a given text document position.

#[must_use]fn goto_type_definition<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/typeDefinition request asks the server for the type definition location of a symbol at a given text document position.

#[must_use]fn goto_implementation<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/implementation request is sent from the client to the server to resolve the implementation location of a symbol at a given text document position.

#[must_use]fn document_symbol<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentSymbolParams
) -> Pin<Box<dyn Future<Output = Result<Option<DocumentSymbolResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/documentSymbol request is sent from the client to the server to retrieve all symbols found in a given text document.

#[must_use]fn code_action<'life0, 'async_trait>(
    &'life0 self,
    params: CodeActionParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CodeActionOrCommand>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/codeAction request is sent from the client to the server to compute commands for a given text document and range. These commands are typically code fixes to either fix problems or to beautify/refactor code.

#[must_use]fn code_lens<'life0, 'async_trait>(
    &'life0 self,
    params: CodeLensParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CodeLens>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/codeLens request is sent from the client to the server to compute code lenses for a given text document.

#[must_use]fn code_lens_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: CodeLens
) -> Pin<Box<dyn Future<Output = Result<CodeLens, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The codeLens/resolve request is sent from the client to the server to resolve the command for a given code lens item.

#[must_use]fn document_link<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentLinkParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<DocumentLink>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/documentLink request is sent from the client to the server to request the location of links in a document.

#[must_use]fn document_link_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentLink
) -> Pin<Box<dyn Future<Output = Result<DocumentLink, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The documentLink/resolve request is sent from the client to the server to resolve the target of a given document link.

#[must_use]fn document_color<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentColorParams
) -> Pin<Box<dyn Future<Output = Result<Vec<ColorInformation>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/documentColor request is sent from the client to the server to list all color references found in a given text document. Along with the range, a color value in RGB is returned.

#[must_use]fn color_presentation<'life0, 'async_trait>(
    &'life0 self,
    params: ColorPresentationParams
) -> Pin<Box<dyn Future<Output = Result<Vec<ColorPresentation>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The [textDocument/colorPresentation] request is sent from the client to the server to obtain a list of presentations for a color value at a given location.

#[must_use]fn formatting<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentFormattingParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/formatting request is sent from the client to the server to format a whole document.

#[must_use]fn range_formatting<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentRangeFormattingParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/rangeFormatting request is sent from the client to the server to format a given range in a document.

#[must_use]fn on_type_formatting<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentOnTypeFormattingParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/onTypeFormatting request is sent from the client to the server to format parts of the document during typing.

#[must_use]fn rename<'life0, 'async_trait>(
    &'life0 self,
    params: RenameParams
) -> Pin<Box<dyn Future<Output = Result<Option<WorkspaceEdit>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/rename request is sent from the client to the server to ask the server to compute a workspace change so that the client can perform a workspace-wide rename of a symbol.

#[must_use]fn prepare_rename<'life0, 'async_trait>(
    &'life0 self,
    params: TextDocumentPositionParams
) -> Pin<Box<dyn Future<Output = Result<Option<PrepareRenameResponse>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/prepareRename request is sent from the client to the server to setup and test the validity of a rename operation at a given location.

#[must_use]fn folding_range<'life0, 'async_trait>(
    &'life0 self,
    params: FoldingRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<FoldingRange>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/foldingRange request is sent from the client to the server to return all folding ranges found in a given text document.

#[must_use]fn selection_range<'life0, 'async_trait>(
    &'life0 self,
    params: SelectionRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<SelectionRange>>, Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The textDocument/selectionRange request is sent from the client to the server to return suggested selection ranges at an array of given positions. A selection range is a range around the cursor position which the user might be interested in selecting.