Struct stc_ts_lang_server::StcLangServer

pub struct StcLangServer {
    pub(crate) client: Client,
}

Fields

client: Client

Trait Implementations

impl LanguageServer for StcLangServer

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 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 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 initialized<'life0, 'async_trait>(
    &'life0 self,
    params: InitializedParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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 did_change_workspace_folders<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeWorkspaceFoldersParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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.

fn did_change_configuration<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeConfigurationParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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.

fn did_change_watched_files<'life0, 'async_trait>(
    &'life0 self,
    params: DidChangeWatchedFilesParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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.

fn symbol<'life0, 'async_trait>(
    &'life0 self,
    params: WorkspaceSymbolParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<SymbolInformation, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn execute_command<'life0, 'async_trait>(
    &'life0 self,
    params: ExecuteCommandParams
) -> Pin<Box<dyn Future<Output = Result<Option<Value>, Error>> + Send + 'async_trait, Global>>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.

fn will_create_files<'life0, 'async_trait>(
    &'life0 self,
    params: CreateFilesParams
) -> Pin<Box<dyn Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The workspace/willCreateFiles request is sent from the client to the server before files are actually created as long as the creation is triggered from within the client.

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

The workspace/didCreateFiles request is sent from the client to the server when files were created from within the client.

fn will_rename_files<'life0, 'async_trait>(
    &'life0 self,
    params: RenameFilesParams
) -> Pin<Box<dyn Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The workspace/willRenameFiles request is sent from the client to the server before files are actually renamed as long as the rename is triggered from within the client.

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

The workspace/didRenameFiles notification is sent from the client to the server when files were renamed from within the client.

fn will_delete_files<'life0, 'async_trait>(
    &'life0 self,
    params: DeleteFilesParams
) -> Pin<Box<dyn Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The workspace/willDeleteFiles request is sent from the client to the server before files are actually deleted as long as the deletion is triggered from within the client either by a user action or by applying a workspace edit.

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

The workspace/didDeleteFiles notification is sent from the client to the server when files were deleted from within the client.

fn did_open<'life0, 'async_trait>(
    &'life0 self,
    params: DidOpenTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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, Global>>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 will_save<'life0, 'async_trait>(
    &'life0 self,
    params: WillSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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.

fn will_save_wait_until<'life0, 'async_trait>(
    &'life0 self,
    params: WillSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn did_save<'life0, 'async_trait>(
    &'life0 self,
    params: DidSaveTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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.

fn did_close<'life0, 'async_trait>(
    &'life0 self,
    params: DidCloseTextDocumentParams
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>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 completion<'life0, 'async_trait>(
    &'life0 self,
    params: CompletionParams
) -> Pin<Box<dyn Future<Output = Result<Option<CompletionResponse>, Error>> + Send + 'async_trait, Global>>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.

fn completion_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: CompletionItem
) -> Pin<Box<dyn Future<Output = Result<CompletionItem, Error>> + Send + 'async_trait, Global>>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.

fn signature_help<'life0, 'async_trait>(
    &'life0 self,
    params: SignatureHelpParams
) -> Pin<Box<dyn Future<Output = Result<Option<SignatureHelp>, Error>> + Send + 'async_trait, Global>>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.

fn goto_declaration<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send + 'async_trait, Global>>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.

fn goto_definition<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send + 'async_trait, Global>>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 goto_type_definition<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send + 'async_trait, Global>>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.

fn goto_implementation<'life0, 'async_trait>(
    &'life0 self,
    params: GotoDefinitionParams
) -> Pin<Box<dyn Future<Output = Result<Option<GotoDefinitionResponse>, Error>> + Send + 'async_trait, Global>>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.

fn references<'life0, 'async_trait>(
    &'life0 self,
    params: ReferenceParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Location, Global>>, Error>> + Send + 'async_trait, Global>>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, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn document_symbol<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentSymbolParams
) -> Pin<Box<dyn Future<Output = Result<Option<DocumentSymbolResponse>, Error>> + Send + 'async_trait, Global>>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.

fn code_action<'life0, 'async_trait>(
    &'life0 self,
    params: CodeActionParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CodeActionOrCommand, Global>>, Error>> + Send + 'async_trait, Global>>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.

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

The codeAction/resolve request is sent from the client to the server to resolve additional information for a given code action.

fn code_lens<'life0, 'async_trait>(
    &'life0 self,
    params: CodeLensParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CodeLens, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn code_lens_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: CodeLens
) -> Pin<Box<dyn Future<Output = Result<CodeLens, Error>> + Send + 'async_trait, Global>>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.

fn document_link<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentLinkParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<DocumentLink, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn document_link_resolve<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentLink
) -> Pin<Box<dyn Future<Output = Result<DocumentLink, Error>> + Send + 'async_trait, Global>>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.

fn document_color<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentColorParams
) -> Pin<Box<dyn Future<Output = Result<Vec<ColorInformation, Global>, Error>> + Send + 'async_trait, Global>>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.

fn color_presentation<'life0, 'async_trait>(
    &'life0 self,
    params: ColorPresentationParams
) -> Pin<Box<dyn Future<Output = Result<Vec<ColorPresentation, Global>, Error>> + Send + 'async_trait, Global>>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.

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

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

fn range_formatting<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentRangeFormattingParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn on_type_formatting<'life0, 'async_trait>(
    &'life0 self,
    params: DocumentOnTypeFormattingParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TextEdit, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn rename<'life0, 'async_trait>(
    &'life0 self,
    params: RenameParams
) -> Pin<Box<dyn Future<Output = Result<Option<WorkspaceEdit>, Error>> + Send + 'async_trait, Global>>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.

fn prepare_rename<'life0, 'async_trait>(
    &'life0 self,
    params: TextDocumentPositionParams
) -> Pin<Box<dyn Future<Output = Result<Option<PrepareRenameResponse>, Error>> + Send + 'async_trait, Global>>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.

fn folding_range<'life0, 'async_trait>(
    &'life0 self,
    params: FoldingRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<FoldingRange, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn selection_range<'life0, 'async_trait>(
    &'life0 self,
    params: SelectionRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<SelectionRange, Global>>, Error>> + Send + 'async_trait, Global>>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.

fn prepare_call_hierarchy<'life0, 'async_trait>(
    &'life0 self,
    params: CallHierarchyPrepareParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CallHierarchyItem, Global>>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/prepareCallHierarchy request is sent from the client to the server to return a call hierarchy for the language element of given text document positions.

fn incoming_calls<'life0, 'async_trait>(
    &'life0 self,
    params: CallHierarchyIncomingCallsParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CallHierarchyIncomingCall, Global>>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The callHierarchy/incomingCalls request is sent from the client to the server to resolve incoming calls for a given call hierarchy item.

fn outgoing_calls<'life0, 'async_trait>(
    &'life0 self,
    params: CallHierarchyOutgoingCallsParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CallHierarchyOutgoingCall, Global>>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The callHierarchy/outgoingCalls request is sent from the client to the server to resolve outgoing calls for a given call hierarchy item.

fn semantic_tokens_full<'life0, 'async_trait>(
    &'life0 self,
    params: SemanticTokensParams
) -> Pin<Box<dyn Future<Output = Result<Option<SemanticTokensResult>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/semanticTokens/full request is sent from the client to the server to resolve the semantic tokens of a given file.

fn semantic_tokens_full_delta<'life0, 'async_trait>(
    &'life0 self,
    params: SemanticTokensDeltaParams
) -> Pin<Box<dyn Future<Output = Result<Option<SemanticTokensFullDeltaResult>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/semanticTokens/full/delta request is sent from the client to the server to resolve the semantic tokens of a given file, returning only the delta.

fn semantic_tokens_range<'life0, 'async_trait>(
    &'life0 self,
    params: SemanticTokensRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<SemanticTokensRangeResult>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/semanticTokens/range request is sent from the client to the server to resolve the semantic tokens for the visible range of a given file.

fn linked_editing_range<'life0, 'async_trait>(
    &'life0 self,
    params: LinkedEditingRangeParams
) -> Pin<Box<dyn Future<Output = Result<Option<LinkedEditingRanges>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/linkedEditingRange request is sent from the client to the server to return for a given position in a document the range of the symbol at the position and all ranges that have the same content.

fn moniker<'life0, 'async_trait>(
    &'life0 self,
    params: MonikerParams
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Moniker, Global>>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

The textDocument/moniker request is sent from the client to the server to get the symbol monikers for a given text document position.