Struct mz_lsp_server::backend::Backend

pub struct Backend {
    pub client: Client,
    pub parse_results: Mutex<HashMap<Url, ParseResult>>,
    pub content: Mutex<HashMap<Url, Rope>>,
    pub formatting_width: Mutex<usize>,
    pub schema: Mutex<Option<Schema>>,
    pub completions: Mutex<Completions>,
}

The Backend struct implements the LanguageServer trait, and thus must provide implementations for its methods. Most imporant methods includes:

• initialize: sets up the server.
• did_open: logs when a file is opened and triggers an on_change method.
• did_save, did_close: log messages indicating file actions.
• completion: Provides completion suggestions. WIP.
• code_lens: Offers in-editor commands. WIP.

Most of the did_ methods re-route the request to the private method on_change within the Backend struct. This method is triggered whenever there’s a change in the file, and it parses the content using mz_sql_parser. Depending on the parse result, it either sneds the logs the results or any encountered errors.

Fields

client: Client

Handles the communication to the client. Logs and results must be sent through the client at the end of each capability.

parse_results: Mutex<HashMap<Url, ParseResult>>

Contains parsing results for each open file. Instead of retrieving the last version from the file each time a command, like formatting, is executed, we use the most recent parsing results stored here. Reading from the file would access old content. E.g. The user formats or performs an action prior to save the file.

content: Mutex<HashMap<Url, Rope>>

Contains the latest content for each file.

formatting_width: Mutex<usize>

Formatting width to use in mz- prettier

schema: Mutex<Option<Schema>>

Schema available in the client used for completion suggestions.

completions: Mutex<Completions>

Completion suggestion to return to the client when requested.

Implementations

impl Backend

async fn parse(&self, params: TextDocumentItem)

Parses the SQL code and publishes diagnosis about it.

fn contains_jinja_code(&self, s: &str) -> bool

Detects if the code contains Jinja code using RegEx and looks for Jinja’s delimiters:

• {% … %} for Statements
• {{ … }} for Expressions to print to the template output
• {# … #} for Comments not included in the template output

Reference: https://jinja.palletsprojects.com/en/3.0.x/templates/#synopsis

The trade-off is that the regex is simple, but it may detect some code as Jinja when it is not actually Jinja. For example: SELECT '{{ 100 }}';. To handle such cases more successfully, the server will first attempt to parse the file, and if it fails, it will then check if it contains Jinja code.

fn is_jinja(&self, s: &str, code: String) -> bool

Returns true if Jinja code is detected.

fn build_completion_items(&self, schema: Schema) -> Completions

Builds the completion items for the following statements:

• SELECT
• FROM

Use this function to build the completion items once, and avoid having to rebuild on every LanguageServer::completion call.

Trait Implementations

impl Debug for Backend

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

Formats the value using the given formatter.

impl LanguageServer for Backend

fn execute_command<'life0, 'async_trait>( &'life0 self, command_params: ExecuteCommandParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes a single command and returns the response. Def: workspace/executeCommand

Commands implemented:

• parse: returns multiple valid statements from a single sql code.

fn completion<'life0, 'async_trait>( &'life0 self, params: CompletionParams, ) -> Pin<Box<dyn Future<Output = Result<Option<CompletionResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Completion implementation.

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

where Self: 'async_trait, 'life0: 'async_trait,

Formats the code using mz_sql_pretty.

Implements the textDocument/formatting language feature.

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

where Self: 'async_trait, 'life0: 'async_trait,

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

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

where Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait,

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

fn did_change_workspace_folders<'life0, 'async_trait>( &'life0 self, __arg1: DidChangeWorkspaceFoldersParams, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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, __arg1: DidChangeConfigurationParams, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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, __arg1: DidChangeWatchedFilesParams, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

where Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait,

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

fn did_save<'life0, 'async_trait>( &'life0 self, __arg1: DidSaveTextDocumentParams, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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, __arg1: DidCloseTextDocumentParams, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

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

fn code_lens<'life0, 'async_trait>( &'life0 self, _params: CodeLensParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CodeLens>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

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

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

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>>, Error>> + Send + 'async_trait>>

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

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>>

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>>

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>>

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>>, Error>> + 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 prepare_call_hierarchy<'life0, 'async_trait>( &'life0 self, params: CallHierarchyPrepareParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<CallHierarchyItem>>, Error>> + Send + 'async_trait>>

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>>, Error>> + Send + 'async_trait>>

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>>, Error>> + Send + 'async_trait>>

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 prepare_type_hierarchy<'life0, 'async_trait>( &'life0 self, params: TypeHierarchyPrepareParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

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

fn supertypes<'life0, 'async_trait>( &'life0 self, params: TypeHierarchySupertypesParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The [typeHierarchy/supertypes] request is sent from the client to the server to resolve the supertypes for a given type hierarchy item.

fn subtypes<'life0, 'async_trait>( &'life0 self, params: TypeHierarchySubtypesParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<TypeHierarchyItem>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The [typeHierarchy/subtypes] request is sent from the client to the server to resolve the subtypes for a given type hierarchy item.

fn document_highlight<'life0, 'async_trait>( &'life0 self, params: DocumentHighlightParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<DocumentHighlight>>, Error>> + 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.

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

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>>

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

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

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>>, Error>> + Send + 'async_trait>>

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

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 semantic_tokens_full<'life0, 'async_trait>( &'life0 self, params: SemanticTokensParams, ) -> Pin<Box<dyn Future<Output = Result<Option<SemanticTokensResult>, Error>> + Send + 'async_trait>>

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>>

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>>

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 inline_value<'life0, 'async_trait>( &'life0 self, params: InlineValueParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<InlineValue>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The textDocument/inlineValue request is sent from the client to the server to compute inline values for a given text document that may be rendered in the editor at the end of lines.

fn inlay_hint<'life0, 'async_trait>( &'life0 self, params: InlayHintParams, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<InlayHint>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The textDocument/inlayHint request is sent from the client to the server to compute inlay hints for a given (text document, range) tuple that may be rendered in the editor in place with other text.

fn inlay_hint_resolve<'life0, 'async_trait>( &'life0 self, params: InlayHint, ) -> Pin<Box<dyn Future<Output = Result<InlayHint, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The inlayHint/resolve request is sent from the client to the server to resolve additional information for a given inlay hint.

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

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.

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

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 diagnostic<'life0, 'async_trait>( &'life0 self, params: DocumentDiagnosticParams, ) -> Pin<Box<dyn Future<Output = Result<DocumentDiagnosticReportResult, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The textDocument/diagnostic request is sent from the client to the server to ask the server to compute the diagnostics for a given document.

fn workspace_diagnostic<'life0, 'async_trait>( &'life0 self, params: WorkspaceDiagnosticParams, ) -> Pin<Box<dyn Future<Output = Result<WorkspaceDiagnosticReportResult, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The workspace/diagnostic request is sent from the client to the server to ask the server to compute workspace wide diagnostics which previously where pushed from the server to the client.

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

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

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>>

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

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>, Error>> + Send + 'async_trait>>

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

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>>, Error>> + Send + 'async_trait>>

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>>

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>>

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 linked_editing_range<'life0, 'async_trait>( &'life0 self, params: LinkedEditingRangeParams, ) -> Pin<Box<dyn Future<Output = Result<Option<LinkedEditingRanges>, Error>> + Send + 'async_trait>>

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

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

where 'life0: 'async_trait, Self: 'async_trait,

The workspaceSymbol/resolve request is sent from the client to the server to resolve additional information for a given workspace symbol.

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

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>>

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>>

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>>

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>>

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>>

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.