From 2d5fce2cdb1254391481a1603be7bfb0872044a5 Mon Sep 17 00:00:00 2001 From: Mathias Fußenegger Date: Mon, 8 Aug 2022 12:34:37 +0200 Subject: feat(lsp): disable exit_timeout by default (#19672) The lsp client used to wait up to 500ms for a language server to shutdown before sending a TERM signal. The intention behind the 500ms grace period was to ensure the language server exits to prevent stale processes, but it has the side-effect that it can interrupt language-servers which are too slow to shutdown within 500ms. Language servers tend to write out index files or project files on shutdown, and being interrupted during this process can cause corruption of those files. This changes the default to not wait at all, at the risk of leaving stale processes around if the language server isn't well behaved. An alternative would be to wait indefinitely, but that can cause neovim to take several seconds to exit. --- runtime/doc/lsp.txt | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 11f96db8c9..48b3f6b4bb 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -1015,12 +1015,13 @@ start_client({config}) *vim.lsp.start_client()* notifications to the server by the given number in milliseconds. No debounce occurs if nil - • exit_timeout (number, default 500): - Milliseconds to wait for server to - exit cleanly after sending the - 'shutdown' request before sending - kill -15. If set to false, nvim - exits immediately after sending the + • exit_timeout (number|boolean, + default false): Milliseconds to + wait for server to exit cleanly + after sending the 'shutdown' + request before sending kill -15. If + set to false, nvim exits + immediately after sending the 'shutdown' request to the server. {root_dir} (string) Directory where the LSP server will base its -- cgit From 68c674af0fbc4158690319aa6125a098a592412d Mon Sep 17 00:00:00 2001 From: Mathias Fußenegger Date: Mon, 8 Aug 2022 18:30:17 +0200 Subject: feat(lsp): set formatexpr by default (#19677) Follow up to https://github.com/neovim/neovim/pull/19003 --- runtime/doc/lsp.txt | 3 +++ 1 file changed, 3 insertions(+) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 48b3f6b4bb..94726ceaab 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -59,6 +59,9 @@ language server supports the functionality. - |tagfunc| is set to |vim.lsp.tagfunc|. This enables features like go-to-definition, |:tjump|, and keymaps like |CTRL-]|, |CTRL-W_]|, |CTRL-W_}| to utilize the language server. +- |formatexpr| is set to |vim.lsp.formatexpr| if both |formatprg| and + |formatexpr| are empty. This allows to format lines via |gq| if the language + server supports it. To use other LSP features like hover, rename, etc. you can setup some additional keymaps. It's recommended to setup them in a |LspAttach| autocmd to -- cgit From ea333badd24f691c753d8048f911d1db349bc2cd Mon Sep 17 00:00:00 2001 From: ii14 Date: Thu, 11 Aug 2022 14:25:48 +0200 Subject: docs: regenerate --- runtime/doc/lsp.txt | 2565 ++++++++++++++++++++++++--------------------------- 1 file changed, 1201 insertions(+), 1364 deletions(-) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 94726ceaab..62b1dceb10 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -10,7 +10,7 @@ Nvim supports the Language Server Protocol (LSP), which means it acts as a client to LSP servers and includes a Lua framework `vim.lsp` for building enhanced LSP tools. - https://microsoft.github.io/language-server-protocol/ + https://microsoft.github.io/language-server-protocol/ LSP facilitates features like go-to-definition, find-references, hover, completion, rename, format, refactor, etc., using semantic whole-project @@ -34,11 +34,11 @@ Follow these steps to get LSP features: 2. Configure the LSP client per language server. A minimal example: > - vim.lsp.start({ - name = 'my-server-name', - cmd = {'name-of-language-server-executable'}, - root_dir = vim.fs.dirname(vim.fs.find({'setup.py', 'pyproject.toml'}, { upward = true })[1]), - }) + vim.lsp.start({ + name = 'my-server-name', + cmd = {'name-of-language-server-executable'}, + root_dir = vim.fs.dirname(vim.fs.find({'setup.py', 'pyproject.toml'}, { upward = true })[1]), + }) < See |vim.lsp.start| for details. @@ -101,7 +101,7 @@ To learn what capabilities are available you can run the following command in a buffer with a started LSP client: > - :lua =vim.lsp.get_active_clients()[1].server_capabilities + :lua =vim.lsp.get_active_clients()[1].server_capabilities < Full list of features provided by default can be found in |lsp-buf|. @@ -163,7 +163,7 @@ LSP request/response handlers are implemented as Lua functions (see |lsp-handler|). The |vim.lsp.handlers| table defines default handlers used when creating a new client. Keys are LSP method names: > - :lua print(vim.inspect(vim.tbl_keys(vim.lsp.handlers))) + :lua print(vim.inspect(vim.tbl_keys(vim.lsp.handlers))) < *lsp-method* @@ -204,84 +204,83 @@ For |lsp-request|, each |lsp-handler| has this signature: > function(err, result, ctx, config) < - Parameters: ~ - {err} (table|nil) - When the language server is unable to complete a - request, a table with information about the error - is sent. Otherwise, it is `nil`. See |lsp-response|. - {result} (Result | Params | nil) - When the language server is able to successfully - complete a request, this contains the `result` key - of the response. See |lsp-response|. - {ctx} (table) - Context describes additional calling state - associated with the handler. It consists of the - following key, value pairs: - - {method} (string) - The |lsp-method| name. - {client_id} (number) - The ID of the |vim.lsp.client|. - {bufnr} (Buffer) - Buffer handle, or 0 for current. - - {params} (table|nil) - The parameters used in the original request - which resulted in this handler - call. - {config} (table) - Configuration for the handler. - - Each handler can define its own configuration - table that allows users to customize the behavior - of a particular handler. - - To configure a particular |lsp-handler|, see: - |lsp-handler-configuration| - - - Returns: ~ - The |lsp-handler| can respond by returning two values: `result, err` - Where `err` must be shaped like an RPC error: - `{ code, message, data? }` - - You can use |vim.lsp.rpc_response_error()| to create this object. + Parameters: ~ + {err} (table|nil) + When the language server is unable to complete a + request, a table with information about the error is + sent. Otherwise, it is `nil`. See |lsp-response|. + {result} (Result | Params | nil) + When the language server is able to successfully + complete a request, this contains the `result` key of + the response. See |lsp-response|. + {ctx} (table) + Context describes additional calling state associated + with the handler. It consists of the following key, + value pairs: + + {method} (string) + The |lsp-method| name. + {client_id} (number) + The ID of the |vim.lsp.client|. + {bufnr} (Buffer) + Buffer handle, or 0 for current. + {params} (table|nil) + The parameters used in the original + request which resulted in this handler + call. + {config} (table) + Configuration for the handler. + + Each handler can define its own configuration table + that allows users to customize the behavior of a + particular handler. + + To configure a particular |lsp-handler|, see: + |lsp-handler-configuration| + + + Returns: ~ + The |lsp-handler| can respond by returning two values: `result, err` + Where `err` must be shaped like an RPC error: + `{ code, message, data? }` + + You can use |vim.lsp.rpc_response_error()| to create this object. For |lsp-notification|, each |lsp-handler| has this signature: > function(err, result, ctx, config) < - Parameters: ~ - {err} (nil) - This is always `nil`. - See |lsp-notification| - {result} (Result) - This contains the `params` key of the notification. - See |lsp-notification| - {ctx} (table) - Context describes additional calling state - associated with the handler. It consists of the - following key, value pairs: - - {method} (string) - The |lsp-method| name. - {client_id} (number) - The ID of the |vim.lsp.client|. - {config} (table) - Configuration for the handler. - - Each handler can define its own configuration - table that allows users to customize the behavior - of a particular handler. - - For an example, see: - |vim.lsp.diagnostic.on_publish_diagnostics()| - - To configure a particular |lsp-handler|, see: - |lsp-handler-configuration| - - Returns: ~ - The |lsp-handler|'s return value will be ignored. + Parameters: ~ + {err} (nil) + This is always `nil`. + See |lsp-notification| + {result} (Result) + This contains the `params` key of the notification. + See |lsp-notification| + {ctx} (table) + Context describes additional calling state associated + with the handler. It consists of the following key, + value pairs: + + {method} (string) + The |lsp-method| name. + {client_id} (number) + The ID of the |vim.lsp.client|. + {config} (table) + Configuration for the handler. + + Each handler can define its own configuration table + that allows users to customize the behavior of a + particular handler. + + For an example, see: + |vim.lsp.diagnostic.on_publish_diagnostics()| + + To configure a particular |lsp-handler|, see: + |lsp-handler-configuration| + + Returns: ~ + The |lsp-handler|'s return value will be ignored. *lsp-handler-configuration* @@ -292,49 +291,50 @@ To configure the behavior of a builtin |lsp-handler|, the convenient method consider the following example, where a new |lsp-handler| is created using |vim.lsp.with()| that no longer generates signs for the diagnostics: > - vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( - vim.lsp.diagnostic.on_publish_diagnostics, { - -- Disable signs - signs = false, - } - ) + vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( + vim.lsp.diagnostic.on_publish_diagnostics, { + -- Disable signs + signs = false, + } + ) < To enable signs, use |vim.lsp.with()| again to create and assign a new |lsp-handler| to |vim.lsp.handlers| for the associated method: > - vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( - vim.lsp.diagnostic.on_publish_diagnostics, { - -- Enable signs - signs = true, - } - ) + vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( + vim.lsp.diagnostic.on_publish_diagnostics, { + -- Enable signs + signs = true, + } + ) < To configure a handler on a per-server basis, you can use the {handlers} key for |vim.lsp.start_client()| > - vim.lsp.start_client { - ..., -- Other configuration omitted. - handlers = { - ["textDocument/publishDiagnostics"] = vim.lsp.with( - vim.lsp.diagnostic.on_publish_diagnostics, { - -- Disable virtual_text - virtual_text = false, - } - }, - } + vim.lsp.start_client { + ..., -- Other configuration omitted. + handlers = { + ["textDocument/publishDiagnostics"] = vim.lsp.with( + vim.lsp.diagnostic.on_publish_diagnostics, { + -- Disable virtual_text + virtual_text = false, + } + ), + }, + } < or if using 'nvim-lspconfig', you can use the {handlers} key of `setup()`: > - require('lspconfig').rust_analyzer.setup { - handlers = { - ["textDocument/publishDiagnostics"] = vim.lsp.with( - vim.lsp.diagnostic.on_publish_diagnostics, { - -- Disable virtual_text - virtual_text = false - } - ), - } - } + require('lspconfig').rust_analyzer.setup { + handlers = { + ["textDocument/publishDiagnostics"] = vim.lsp.with( + vim.lsp.diagnostic.on_publish_diagnostics, { + -- Disable virtual_text + virtual_text = false + } + ), + } + } < Some handlers do not have an explicitly named handler function (such as |on_publish_diagnostics()|). To override these, first create a reference @@ -357,31 +357,31 @@ Handlers can be set by: To override the handler for the `"textDocument/definition"` method: > - vim.lsp.handlers["textDocument/definition"] = my_custom_default_definition + vim.lsp.handlers["textDocument/definition"] = my_custom_default_definition < - The {handlers} parameter for |vim.lsp.start_client|. This will set the |lsp-handler| as the default handler for this server. For example: > - vim.lsp.start_client { - ..., -- Other configuration omitted. - handlers = { + vim.lsp.start_client { + ..., -- Other configuration omitted. + handlers = { ["textDocument/definition"] = my_custom_server_definition - }, - } + }, + } - The {handler} parameter for |vim.lsp.buf_request()|. This will set the |lsp-handler| ONLY for the current request. For example: > - vim.lsp.buf_request( - 0, - "textDocument/definition", - definition_params, - my_request_custom_definition - ) + vim.lsp.buf_request( + 0, + "textDocument/definition", + definition_params, + my_request_custom_definition + ) < In summary, the |lsp-handler| will be chosen based on the current |lsp-method| in the following order: @@ -403,8 +403,8 @@ https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specificatio For example `vim.lsp.protocol.ErrorCodes` allows reverse lookup by number or name: > - vim.lsp.protocol.TextDocumentSyncKind.Full == 1 - vim.lsp.protocol.TextDocumentSyncKind[1] == "Full" + vim.lsp.protocol.TextDocumentSyncKind.Full == 1 + vim.lsp.protocol.TextDocumentSyncKind[1] == "Full" < *lsp-response* @@ -424,22 +424,22 @@ For the format of the notification message, see: - `context` table|nil. `ctx` from |lsp-handler| This table can be used with vim.fn.setqflist or vim.fn.setloclist. E.g.: +> + local function on_list(options) + vim.fn.setqflist({}, ' ', options) + vim.api.nvim_command('cfirst') + end - local function on_list(options) - vim.fn.setqflist({}, ' ', options) - vim.api.nvim_command('cfirst') - end - - vim.lsp.buf.definition{on_list=on_list} - vim.lsp.buf.references(nil, {on_list=on_list}) - + vim.lsp.buf.definition{on_list=on_list} + vim.lsp.buf.references(nil, {on_list=on_list}) +< If you prefer loclist do something like this: - - local function on_list(options) - vim.fn.setloclist(0, {}, ' ', options) - vim.api.nvim_command('lopen') - end - +> + local function on_list(options) + vim.fn.setloclist(0, {}, ' ', options) + vim.api.nvim_command('lopen') + end +< ================================================================================ LSP HIGHLIGHT *lsp-highlight* @@ -464,11 +464,11 @@ Highlight groups related to |lsp-codelens| functionality. *hl-LspCodeLens* LspCodeLens - Used to color the virtual text of the codelens. See - |nvim_buf_set_extmark()|. + Used to color the virtual text of the codelens. See + |nvim_buf_set_extmark()|. LspCodeLensSeparator *hl-LspCodeLensSeparator* - Used to color the separator between two or more code lens. + Used to color the separator between two or more code lens. *lsp-highlight-signature* @@ -476,8 +476,8 @@ Highlight groups related to |vim.lsp.handlers.signature_help()|. *hl-LspSignatureActiveParameter* LspSignatureActiveParameter - Used to highlight the active parameter in the signature help. See - |vim.lsp.handlers.signature_help()|. + Used to highlight the active parameter in the signature help. See + |vim.lsp.handlers.signature_help()|. ============================================================================== EVENTS *lsp-events* @@ -516,317 +516,286 @@ callback in the "data" table. Example: > In addition, the following |User| |autocommands| are provided: LspProgressUpdate *LspProgressUpdate* - Upon receipt of a progress notification from the server. See - |vim.lsp.util.get_progress_messages()|. + Upon receipt of a progress notification from the server. See + |vim.lsp.util.get_progress_messages()|. LspRequest *LspRequest* - After a change to the active set of pending LSP requests. See {requests} - in |vim.lsp.client|. + After a change to the active set of pending LSP requests. See {requests} + in |vim.lsp.client|. Example: > - autocmd User LspProgressUpdate redrawstatus - autocmd User LspRequest redrawstatus + autocmd User LspProgressUpdate redrawstatus + autocmd User LspRequest redrawstatus < ============================================================================== Lua module: vim.lsp *lsp-core* buf_attach_client({bufnr}, {client_id}) *vim.lsp.buf_attach_client()* - Implements the `textDocument/did…` notifications required to - track a buffer for any language server. + Implements the `textDocument/did…` notifications required to track a + buffer for any language server. - Without calling this, the server won't be notified of changes - to a buffer. + Without calling this, the server won't be notified of changes to a buffer. - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current - {client_id} (number) Client id + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current + {client_id} (number) Client id buf_detach_client({bufnr}, {client_id}) *vim.lsp.buf_detach_client()* - Detaches client from the specified buffer. Note: While the - server is notified that the text document (buffer) was closed, - it is still able to send notifications should it ignore this - notification. + Detaches client from the specified buffer. Note: While the server is + notified that the text document (buffer) was closed, it is still able to + send notifications should it ignore this notification. - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current - {client_id} (number) Client id + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current + {client_id} (number) Client id buf_is_attached({bufnr}, {client_id}) *vim.lsp.buf_is_attached()* - Checks if a buffer is attached for a particular client. + Checks if a buffer is attached for a particular client. - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current - {client_id} (number) the client id + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current + {client_id} (number) the client id buf_notify({bufnr}, {method}, {params}) *vim.lsp.buf_notify()* - Send a notification to a server + Send a notification to a server - Parameters: ~ - {bufnr} [number] (optional): The number of the buffer - {method} [string]: Name of the request method - {params} [string]: Arguments to send to the server + Parameters: ~ + {bufnr} [number] (optional): The number of the buffer + {method} [string]: Name of the request method + {params} [string]: Arguments to send to the server - Return: ~ - true if any client returns true; false otherwise + Return: ~ + true if any client returns true; false otherwise *vim.lsp.buf_request()* buf_request({bufnr}, {method}, {params}, {handler}) - Sends an async request for all active clients attached to the - buffer. - - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current. - {method} (string) LSP method name - {params} (optional, table) Parameters to send to the - server - {handler} (optional, function) See |lsp-handler| If nil, - follows resolution strategy defined in - |lsp-handler-configuration| - - Return: ~ - 2-tuple: - • Map of client-id:request-id pairs for all successful - requests. - • Function which can be used to cancel all the requests. - You could instead iterate all clients and call their - `cancel_request()` methods. + Sends an async request for all active clients attached to the buffer. + + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current. + {method} (string) LSP method name + {params} (optional, table) Parameters to send to the server + {handler} (optional, function) See |lsp-handler| If nil, follows + resolution strategy defined in |lsp-handler-configuration| + + Return: ~ + 2-tuple: + • Map of client-id:request-id pairs for all successful requests. + • Function which can be used to cancel all the requests. You could + instead iterate all clients and call their `cancel_request()` + methods. *vim.lsp.buf_request_all()* buf_request_all({bufnr}, {method}, {params}, {callback}) - Sends an async request for all active clients attached to the - buffer. Executes the callback on the combined result. - Parameters are the same as |vim.lsp.buf_request()| but the - return result and callback are different. - - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current. - {method} (string) LSP method name - {params} (optional, table) Parameters to send to the - server - {callback} (function) The callback to call when all - requests are finished. - - Return: ~ - (function) A function that will cancel all requests which - is the same as the one returned from `buf_request`. + Sends an async request for all active clients attached to the buffer. + Executes the callback on the combined result. Parameters are the same as + |vim.lsp.buf_request()| but the return result and callback are different. + + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current. + {method} (string) LSP method name + {params} (optional, table) Parameters to send to the server + {callback} (function) The callback to call when all requests are + finished. + + Return: ~ + (function) A function that will cancel all requests which is the same + as the one returned from `buf_request`. *vim.lsp.buf_request_sync()* buf_request_sync({bufnr}, {method}, {params}, {timeout_ms}) - Sends a request to all server and waits for the response of - all of them. - - Calls |vim.lsp.buf_request_all()| but blocks Nvim while - awaiting the result. Parameters are the same as - |vim.lsp.buf_request()| but the return result is different. - Wait maximum of {timeout_ms} (default 1000) ms. - - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current. - {method} (string) LSP method name - {params} (optional, table) Parameters to send to the - server - {timeout_ms} (optional, number, default=1000) Maximum - time in milliseconds to wait for a result. - - Return: ~ - Map of client_id:request_result. On timeout, cancel or - error, returns `(nil, err)` where `err` is a string - describing the failure reason. + Sends a request to all server and waits for the response of all of them. + + Calls |vim.lsp.buf_request_all()| but blocks Nvim while awaiting the + result. Parameters are the same as |vim.lsp.buf_request()| but the return + result is different. Wait maximum of {timeout_ms} (default 1000) ms. + + Parameters: ~ + {bufnr} (number) Buffer handle, or 0 for current. + {method} (string) LSP method name + {params} (optional, table) Parameters to send to the server + {timeout_ms} (optional, number, default=1000) Maximum time in + milliseconds to wait for a result. + + Return: ~ + Map of client_id:request_result. On timeout, cancel or error, returns + `(nil, err)` where `err` is a string describing the failure reason. client() *vim.lsp.client* - LSP client object. You can get an active client object via - |vim.lsp.get_client_by_id()| or - |vim.lsp.get_active_clients()|. - - • Methods: - • request(method, params, [handler], bufnr) Sends a request - to the server. This is a thin wrapper around - {client.rpc.request} with some additional checking. If - {handler} is not specified, If one is not found there, - then an error will occur. Returns: {status}, - {[client_id]}. {status} is a boolean indicating if the - notification was successful. If it is `false`, then it - will always be `false` (the client has shutdown). If - {status} is `true`, the function returns {request_id} as - the second result. You can use this with - `client.cancel_request(request_id)` to cancel the request. - • request_sync(method, params, timeout_ms, bufnr) Sends a - request to the server and synchronously waits for the - response. This is a wrapper around {client.request} - Returns: { err=err, result=result }, a dictionary, where - `err` and `result` come from the |lsp-handler|. On - timeout, cancel or error, returns `(nil, err)` where `err` - is a string describing the failure reason. If the request - was unsuccessful returns `nil`. - • notify(method, params) Sends a notification to an LSP - server. Returns: a boolean to indicate if the notification - was successful. If it is false, then it will always be - false (the client has shutdown). - • cancel_request(id) Cancels a request with a given request - id. Returns: same as `notify()`. - • stop([force]) Stops a client, optionally with force. By - default, it will just ask the server to shutdown without - force. If you request to stop a client which has - previously been requested to shutdown, it will - automatically escalate and force shutdown. - • is_stopped() Checks whether a client is stopped. Returns: - true if the client is fully stopped. - • on_attach(client, bufnr) Runs the on_attach function from - the client's config if it was defined. Useful for - buffer-local setup. - - • Members - • {id} (number): The id allocated to the client. - • {name} (string): If a name is specified on creation, that - will be used. Otherwise it is just the client id. This is - used for logs and messages. - • {rpc} (table): RPC client object, for low level - interaction with the client. See |vim.lsp.rpc.start()|. - • {offset_encoding} (string): The encoding used for - communicating with the server. You can modify this in the - `config`'s `on_init` method before text is sent to the - server. - • {handlers} (table): The handlers used by the client as - described in |lsp-handler|. - • {requests} (table): The current pending requests in flight - to the server. Entries are key-value pairs with the key - being the request ID while the value is a table with - `type`, `bufnr`, and `method` key-value pairs. `type` is - either "pending" for an active request, or "cancel" for a - cancel request. - • {config} (table): copy of the table that was passed by the - user to |vim.lsp.start_client()|. - • {server_capabilities} (table): Response from the server - sent on `initialize` describing the server's capabilities. + LSP client object. You can get an active client object via + |vim.lsp.get_client_by_id()| or |vim.lsp.get_active_clients()|. + + • Methods: + • request(method, params, [handler], bufnr) Sends a request to the + server. This is a thin wrapper around {client.rpc.request} with some + additional checking. If {handler} is not specified, If one is not + found there, then an error will occur. Returns: {status}, + {[client_id]}. {status} is a boolean indicating if the notification + was successful. If it is `false`, then it will always be `false` (the + client has shutdown). If {status} is `true`, the function returns + {request_id} as the second result. You can use this with + `client.cancel_request(request_id)` to cancel the request. + • request_sync(method, params, timeout_ms, bufnr) Sends a request to the + server and synchronously waits for the response. This is a wrapper + around {client.request} Returns: { err=err, result=result }, a + dictionary, where `err` and `result` come from the |lsp-handler|. On + timeout, cancel or error, returns `(nil, err)` where `err` is a string + describing the failure reason. If the request was unsuccessful returns + `nil`. + • notify(method, params) Sends a notification to an LSP server. Returns: + a boolean to indicate if the notification was successful. If it is + false, then it will always be false (the client has shutdown). + • cancel_request(id) Cancels a request with a given request id. Returns: + same as `notify()`. + • stop([force]) Stops a client, optionally with force. By default, it + will just ask the server to shutdown without force. If you request to + stop a client which has previously been requested to shutdown, it will + automatically escalate and force shutdown. + • is_stopped() Checks whether a client is stopped. Returns: true if the + client is fully stopped. + • on_attach(client, bufnr) Runs the on_attach function from the client's + config if it was defined. Useful for buffer-local setup. + + • Members + • {id} (number): The id allocated to the client. + • {name} (string): If a name is specified on creation, that will be + used. Otherwise it is just the client id. This is used for logs and + messages. + • {rpc} (table): RPC client object, for low level interaction with the + client. See |vim.lsp.rpc.start()|. + • {offset_encoding} (string): The encoding used for communicating with + the server. You can modify this in the `config`'s `on_init` method + before text is sent to the server. + • {handlers} (table): The handlers used by the client as described in + |lsp-handler|. + • {requests} (table): The current pending requests in flight to the + server. Entries are key-value pairs with the key being the request ID + while the value is a table with `type`, `bufnr`, and `method` + key-value pairs. `type` is either "pending" for an active request, or + "cancel" for a cancel request. + • {config} (table): copy of the table that was passed by the user to + |vim.lsp.start_client()|. + • {server_capabilities} (table): Response from the server sent on + `initialize` describing the server's capabilities. client_is_stopped({client_id}) *vim.lsp.client_is_stopped()* - Checks whether a client is stopped. + Checks whether a client is stopped. - Parameters: ~ - {client_id} (Number) + Parameters: ~ + {client_id} (Number) - Return: ~ - true if client is stopped, false otherwise. + Return: ~ + true if client is stopped, false otherwise. *vim.lsp.for_each_buffer_client()* for_each_buffer_client({bufnr}, {fn}) - Invokes a function for each LSP client attached to a buffer. - - Parameters: ~ - {bufnr} (number) Buffer number - {fn} (function) Function to run on each client - attached to buffer {bufnr}. The function takes - the client, client ID, and buffer number as - arguments. Example: > - - vim.lsp.for_each_buffer_client(0, function(client, client_id, bufnr) - print(vim.inspect(client)) - end) + Invokes a function for each LSP client attached to a buffer. + + Parameters: ~ + {bufnr} (number) Buffer number + {fn} (function) Function to run on each client attached to buffer + {bufnr}. The function takes the client, client ID, and buffer + number as arguments. Example: > + + vim.lsp.for_each_buffer_client(0, function(client, client_id, bufnr) + print(vim.inspect(client)) + end) < formatexpr({opts}) *vim.lsp.formatexpr()* - Provides an interface between the built-in client and a - `formatexpr` function. - - Currently only supports a single client. This can be set via - `setlocal formatexpr=v:lua.vim.lsp.formatexpr()` but will - typically or in `on_attach` via - `vim.api.nvim_buf_set_option(bufnr, 'formatexpr', - 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`. - - Parameters: ~ - {opts} (table) options for customizing the formatting - expression which takes the following optional - keys: - • timeout_ms (default 500ms). The timeout period - for the formatting request. + Provides an interface between the built-in client and a `formatexpr` + function. + + Currently only supports a single client. This can be set via `setlocal + formatexpr=v:lua.vim.lsp.formatexpr()` but will typically or in + `on_attach` via `vim.api.nvim_buf_set_option(bufnr, 'formatexpr', + 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`. + + Parameters: ~ + {opts} (table) options for customizing the formatting expression + which takes the following optional keys: + • timeout_ms (default 500ms). The timeout period for the + formatting request. get_active_clients({filter}) *vim.lsp.get_active_clients()* - Get active clients. - - Parameters: ~ - {filter} (table|nil) A table with key-value pairs used to - filter the returned clients. The available keys - are: - • id (number): Only return clients with the - given id - • bufnr (number): Only return clients attached - to this buffer - • name (string): Only return clients with the - given name - - Return: ~ - (table) List of |vim.lsp.client| objects + Get active clients. + + Parameters: ~ + {filter} (table|nil) A table with key-value pairs used to filter the + returned clients. The available keys are: + • id (number): Only return clients with the given id + • bufnr (number): Only return clients attached to this + buffer + • name (string): Only return clients with the given name + + Return: ~ + (table) List of |vim.lsp.client| objects *vim.lsp.get_buffers_by_client_id()* get_buffers_by_client_id({client_id}) - Returns list of buffers attached to client_id. + Returns list of buffers attached to client_id. - Parameters: ~ - {client_id} (number) client id + Parameters: ~ + {client_id} (number) client id - Return: ~ - list of buffer ids + Return: ~ + list of buffer ids get_client_by_id({client_id}) *vim.lsp.get_client_by_id()* - Gets a client by id, or nil if the id is invalid. The returned - client may not yet be fully initialized. + Gets a client by id, or nil if the id is invalid. The returned client may + not yet be fully initialized. - Parameters: ~ - {client_id} (number) client id + Parameters: ~ + {client_id} (number) client id - Return: ~ - |vim.lsp.client| object, or nil + Return: ~ + |vim.lsp.client| object, or nil get_log_path() *vim.lsp.get_log_path()* - Gets the path of the logfile used by the LSP client. + Gets the path of the logfile used by the LSP client. - Return: ~ - (String) Path to logfile. + Return: ~ + (String) Path to logfile. omnifunc({findstart}, {base}) *vim.lsp.omnifunc()* - Implements 'omnifunc' compatible LSP completion. + Implements 'omnifunc' compatible LSP completion. - Parameters: ~ - {findstart} 0 or 1, decides behavior - {base} If findstart=0, text to match against + Parameters: ~ + {findstart} 0 or 1, decides behavior + {base} If findstart=0, text to match against - Return: ~ - (number) Decided by {findstart}: - • findstart=0: column where the completion starts, or -2 - or -3 - • findstart=1: list of matches (actually just calls - |complete()|) + Return: ~ + (number) Decided by {findstart}: + • findstart=0: column where the completion starts, or -2 or -3 + • findstart=1: list of matches (actually just calls |complete()|) - See also: ~ - |complete-functions| - |complete-items| - |CompleteDone| + See also: ~ + |complete-functions| + |complete-items| + |CompleteDone| set_log_level({level}) *vim.lsp.set_log_level()* - Sets the global log level for LSP logging. + Sets the global log level for LSP logging. - Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR", - "OFF" + Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF" - Level numbers begin with "TRACE" at 0 + Level numbers begin with "TRACE" at 0 - Use `lsp.log_levels` for reverse lookup. + Use `lsp.log_levels` for reverse lookup. - Parameters: ~ - {level} [number|string] the case insensitive level name - or number + Parameters: ~ + {level} [number|string] the case insensitive level name or number - See also: ~ - |vim.lsp.log_levels| + See also: ~ + |vim.lsp.log_levels| start({config}, {opts}) *vim.lsp.start()* - Create a new LSP client and start a language server or reuses - an already running client if one is found matching `name` and - `root_dir`. Attaches the current buffer to the client. + Create a new LSP client and start a language server or reuses an already + running client if one is found matching `name` and `root_dir`. Attaches + the current buffer to the client. - Example: + Example: > vim.lsp.start({ @@ -836,249 +805,208 @@ start({config}, {opts}) *vim.lsp.start()* }) < - See |lsp.start_client| for all available options. The most - important are: - - `name` is an arbitrary name for the LSP client. It should be - unique per language server. - - `cmd` the command as list - used to start the language server. The - command must be present in the `$PATH` environment variable or an absolute path to the executable. - Shell constructs like `~` are NOT expanded. - - `root_dir` path to the project root. By default this is used - to decide if an existing client should be re-used. The example - above uses |vim.fs.find| and |vim.fs.dirname| to detect the - root by traversing the file system upwards starting from the - current directory until either a `pyproject.toml` or - `setup.py` file is found. - - `workspace_folders` a list of { uri:string, name: string } - tables. The project root folders used by the language server. - If `nil` the property is derived from the `root_dir` for - convenience. - - Language servers use this information to discover metadata - like the dependencies of your project and they tend to index - the contents within the project folder. - - To ensure a language server is only started for languages it - can handle, make sure to call |vim.lsp.start| within a - |FileType| autocmd. Either use |:au|, |nvim_create_autocmd()| - or put the call in a `ftplugin/.lua` (See - |ftplugin-name|) - - Parameters: ~ - {config} (table) Same configuration as documented in - |lsp.start_client()| - {opts} nil|table Optional keyword arguments: - • reuse_client (fun(client: client, config: - table): boolean) Predicate used to decide if a - client should be re-used. Used on all running - clients. The default implementation re-uses a - client if name and root_dir matches. - - Return: ~ - (number) client_id + See |lsp.start_client| for all available options. The most important are: + + `name` is an arbitrary name for the LSP client. It should be unique per + language server. + + `cmd` the command as list - used to start the language server. The command must + be present in the `$PATH` environment variable or an absolute path to the executable. Shell + constructs like `~` are NOT expanded. + + `root_dir` path to the project root. By default this is used to decide if + an existing client should be re-used. The example above uses |vim.fs.find| + and |vim.fs.dirname| to detect the root by traversing the file system + upwards starting from the current directory until either a + `pyproject.toml` or `setup.py` file is found. + + `workspace_folders` a list of { uri:string, name: string } tables. The + project root folders used by the language server. If `nil` the property is + derived from the `root_dir` for convenience. + + Language servers use this information to discover metadata like the + dependencies of your project and they tend to index the contents within + the project folder. + + To ensure a language server is only started for languages it can handle, + make sure to call |vim.lsp.start| within a |FileType| autocmd. Either use + |:au|, |nvim_create_autocmd()| or put the call in a + `ftplugin/.lua` (See |ftplugin-name|) + + Parameters: ~ + {config} (table) Same configuration as documented in + |lsp.start_client()| + {opts} nil|table Optional keyword arguments: + • reuse_client (fun(client: client, config: table): boolean) + Predicate used to decide if a client should be re-used. + Used on all running clients. The default implementation + re-uses a client if name and root_dir matches. + + Return: ~ + (number) client_id start_client({config}) *vim.lsp.start_client()* - Starts and initializes a client with the given configuration. - - Parameter `cmd` is required. - - The following parameters describe fields in the {config} - table. - - Parameters: ~ - {cmd} (required, string or list treated - like |jobstart()|) Base command that - initiates the LSP client. - {cmd_cwd} (string, default=|getcwd()|) - Directory to launch the `cmd` - process. Not related to `root_dir`. - {cmd_env} (table) Environment flags to pass to - the LSP on spawn. Can be specified - using keys like a map or as a list - with `k=v` pairs or both. Non-string values are - coerced to string. Example: > - - { "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; } + Starts and initializes a client with the given configuration. + + Parameter `cmd` is required. + + The following parameters describe fields in the {config} table. + + Parameters: ~ + {cmd} (required, string or list treated like + |jobstart()|) Base command that initiates the LSP + client. + {cmd_cwd} (string, default=|getcwd()|) Directory to launch + the `cmd` process. Not related to `root_dir`. + {cmd_env} (table) Environment flags to pass to the LSP on + spawn. Can be specified using keys like a map or + as a list with `k=v` pairs or both. Non-string values are coerced to + string. Example: > + + { "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; } < - {detached} (boolean, default true) Daemonize the - server process so that it runs in a - separate process group from Nvim. - Nvim will shutdown the process on - exit, but if Nvim fails to exit - cleanly this could leave behind - orphaned server processes. - {workspace_folders} (table) List of workspace folders - passed to the language server. For - backwards compatibility rootUri and - rootPath will be derived from the - first workspace folder in this list. - See `workspaceFolders` in the LSP - spec. - {capabilities} Map overriding the default - capabilities defined by - |vim.lsp.protocol.make_client_capabilities()|, - passed to the language server on - initialization. Hint: use - make_client_capabilities() and modify - its result. - • Note: To send an empty dictionary - use - `{[vim.type_idx]=vim.types.dictionary}`, - else it will be encoded as an - array. - {handlers} Map of language server method names - to |lsp-handler| - {settings} Map with language server specific - settings. These are returned to the - language server if requested via - `workspace/configuration`. Keys are - case-sensitive. - {commands} (table) Table that maps string of - clientside commands to user-defined - functions. Commands passed to - start_client take precedence over the - global command registry. Each key - must be a unique command name, and - the value is a function which is - called if any LSP action (code - action, code lenses, ...) triggers - the command. - {init_options} Values to pass in the initialization - request as `initializationOptions`. - See `initialize` in the LSP spec. - {name} (string, default=client-id) Name in - log messages. - {get_language_id} function(bufnr, filetype) -> language - ID as string. Defaults to the - filetype. - {offset_encoding} (default="utf-16") One of "utf-8", - "utf-16", or "utf-32" which is the - encoding that the LSP server expects. - Client does not verify this is - correct. - {on_error} Callback with parameters (code, ...), - invoked when the client operation - throws an error. `code` is a number - describing the error. Other arguments - may be passed depending on the error - kind. See |vim.lsp.rpc.client_errors| - for possible errors. Use - `vim.lsp.rpc.client_errors[code]` to - get human-friendly name. - {before_init} Callback with parameters - (initialize_params, config) invoked - before the LSP "initialize" phase, - where `params` contains the - parameters being sent to the server - and `config` is the config that was - passed to |vim.lsp.start_client()|. - You can use this to modify parameters - before they are sent. - {on_init} Callback (client, initialize_result) - invoked after LSP "initialize", where - `result` is a table of `capabilities` - and anything else the server may - send. For example, clangd sends - `initialize_result.offsetEncoding` if - `capabilities.offsetEncoding` was - sent to it. You can only modify the - `client.offset_encoding` here before - any notifications are sent. Most - language servers expect to be sent - client specified settings after - initialization. Neovim does not make - this assumption. A - `workspace/didChangeConfiguration` - notification should be sent to the - server during on_init. - {on_exit} Callback (code, signal, client_id) - invoked on client exit. - • code: exit code of the process - • signal: number describing the - signal used to terminate (if any) - • client_id: client handle - {on_attach} Callback (client, bufnr) invoked when - client attaches to a buffer. - {trace} "off" | "messages" | "verbose" | nil - passed directly to the language - server in the initialize request. - Invalid/empty values will default to - "off" - {flags} A table with flags for the client. - The current (experimental) flags are: - • allow_incremental_sync (bool, - default true): Allow using - incremental sync for buffer edits - • debounce_text_changes (number, - default 150): Debounce didChange - notifications to the server by the - given number in milliseconds. No - debounce occurs if nil - • exit_timeout (number|boolean, - default false): Milliseconds to - wait for server to exit cleanly - after sending the 'shutdown' - request before sending kill -15. If - set to false, nvim exits - immediately after sending the - 'shutdown' request to the server. - {root_dir} (string) Directory where the LSP - server will base its - workspaceFolders, rootUri, and - rootPath on initialization. - - Return: ~ - Client id. |vim.lsp.get_client_by_id()| Note: client may - not be fully initialized. Use `on_init` to do any actions - once the client has been initialized. + {detached} (boolean, default true) Daemonize the server + process so that it runs in a separate process + group from Nvim. Nvim will shutdown the process + on exit, but if Nvim fails to exit cleanly this + could leave behind orphaned server processes. + {workspace_folders} (table) List of workspace folders passed to the + language server. For backwards compatibility + rootUri and rootPath will be derived from the + first workspace folder in this list. See + `workspaceFolders` in the LSP spec. + {capabilities} Map overriding the default capabilities defined + by |vim.lsp.protocol.make_client_capabilities()|, + passed to the language server on initialization. + Hint: use make_client_capabilities() and modify + its result. + • Note: To send an empty dictionary use + `{[vim.type_idx]=vim.types.dictionary}`, else + it will be encoded as an array. + {handlers} Map of language server method names to + |lsp-handler| + {settings} Map with language server specific settings. These + are returned to the language server if requested + via `workspace/configuration`. Keys are + case-sensitive. + {commands} (table) Table that maps string of clientside + commands to user-defined functions. Commands + passed to start_client take precedence over the + global command registry. Each key must be a + unique command name, and the value is a function + which is called if any LSP action (code action, + code lenses, ...) triggers the command. + {init_options} Values to pass in the initialization request as + `initializationOptions`. See `initialize` in the + LSP spec. + {name} (string, default=client-id) Name in log messages. + {get_language_id} function(bufnr, filetype) -> language ID as + string. Defaults to the filetype. + {offset_encoding} (default="utf-16") One of "utf-8", "utf-16", or + "utf-32" which is the encoding that the LSP + server expects. Client does not verify this is + correct. + {on_error} Callback with parameters (code, ...), invoked + when the client operation throws an error. `code` + is a number describing the error. Other arguments + may be passed depending on the error kind. See + |vim.lsp.rpc.client_errors| for possible errors. + Use `vim.lsp.rpc.client_errors[code]` to get + human-friendly name. + {before_init} Callback with parameters (initialize_params, + config) invoked before the LSP "initialize" + phase, where `params` contains the parameters + being sent to the server and `config` is the + config that was passed to + |vim.lsp.start_client()|. You can use this to + modify parameters before they are sent. + {on_init} Callback (client, initialize_result) invoked + after LSP "initialize", where `result` is a table + of `capabilities` and anything else the server + may send. For example, clangd sends + `initialize_result.offsetEncoding` if + `capabilities.offsetEncoding` was sent to it. You + can only modify the `client.offset_encoding` here + before any notifications are sent. Most language + servers expect to be sent client specified + settings after initialization. Neovim does not + make this assumption. A + `workspace/didChangeConfiguration` notification + should be sent to the server during on_init. + {on_exit} Callback (code, signal, client_id) invoked on + client exit. + • code: exit code of the process + • signal: number describing the signal used to + terminate (if any) + • client_id: client handle + {on_attach} Callback (client, bufnr) invoked when client + attaches to a buffer. + {trace} "off" | "messages" | "verbose" | nil passed + directly to the language server in the initialize + request. Invalid/empty values will default to + "off" + {flags} A table with flags for the client. The current + (experimental) flags are: + • allow_incremental_sync (bool, default true): + Allow using incremental sync for buffer edits + • debounce_text_changes (number, default 150): + Debounce didChange notifications to the server + by the given number in milliseconds. No + debounce occurs if nil + • exit_timeout (number|boolean, default false): + Milliseconds to wait for server to exit cleanly + after sending the 'shutdown' request before + sending kill -15. If set to false, nvim exits + immediately after sending the 'shutdown' + request to the server. + {root_dir} (string) Directory where the LSP server will base + its workspaceFolders, rootUri, and rootPath on + initialization. + + Return: ~ + Client id. |vim.lsp.get_client_by_id()| Note: client may not be fully + initialized. Use `on_init` to do any actions once the client has been + initialized. stop_client({client_id}, {force}) *vim.lsp.stop_client()* - Stops a client(s). + Stops a client(s). - You can also use the `stop()` function on a |vim.lsp.client| - object. To stop all clients: + You can also use the `stop()` function on a |vim.lsp.client| object. To + stop all clients: > vim.lsp.stop_client(vim.lsp.get_active_clients()) < - By default asks the server to shutdown, unless stop was - requested already for this client, then force-shutdown is - attempted. + By default asks the server to shutdown, unless stop was requested already + for this client, then force-shutdown is attempted. - Parameters: ~ - {client_id} client id or |vim.lsp.client| object, or list - thereof - {force} (boolean) (optional) shutdown forcefully + Parameters: ~ + {client_id} client id or |vim.lsp.client| object, or list thereof + {force} (boolean) (optional) shutdown forcefully tagfunc({...}) *vim.lsp.tagfunc()* - Provides an interface between the built-in client and - 'tagfunc'. + Provides an interface between the built-in client and 'tagfunc'. - When used with normal mode commands (e.g. |CTRL-]|) this will - invoke the "textDocument/definition" LSP method to find the - tag under the cursor. Otherwise, uses "workspace/symbol". If - no results are returned from any LSP servers, falls back to - using built-in tags. + When used with normal mode commands (e.g. |CTRL-]|) this will invoke the + "textDocument/definition" LSP method to find the tag under the cursor. + Otherwise, uses "workspace/symbol". If no results are returned from any + LSP servers, falls back to using built-in tags. - Parameters: ~ - {pattern} Pattern used to find a workspace symbol - {flags} See |tag-function| + Parameters: ~ + {pattern} Pattern used to find a workspace symbol + {flags} See |tag-function| - Return: ~ - A list of matching tags + Return: ~ + A list of matching tags with({handler}, {override_config}) *vim.lsp.with()* - Function to manage overriding defaults for LSP handlers. + Function to manage overriding defaults for LSP handlers. - Parameters: ~ - {handler} (function) See |lsp-handler| - {override_config} (table) Table containing the keys to - override behavior of the {handler} + Parameters: ~ + {handler} (function) See |lsp-handler| + {override_config} (table) Table containing the keys to override + behavior of the {handler} ============================================================================== @@ -1086,471 +1014,432 @@ Lua module: vim.lsp.buf *lsp-buf* *vim.lsp.buf.add_workspace_folder()* add_workspace_folder({workspace_folder}) - Add the folder at path to the workspace folders. If {path} is - not provided, the user will be prompted for a path using - |input()|. + Add the folder at path to the workspace folders. If {path} is not + provided, the user will be prompted for a path using |input()|. clear_references() *vim.lsp.buf.clear_references()* - Removes document highlights from current buffer. + Removes document highlights from current buffer. code_action({options}) *vim.lsp.buf.code_action()* - Selects a code action available at the current cursor - position. - - Parameters: ~ - {options} (table|nil) Optional table which holds the - following optional fields: - • context: (table|nil) Corresponds to `CodeActionContext` of the LSP specification: - • diagnostics (table|nil): LSP`Diagnostic[]` . Inferred from the current position if not - provided. - • only (table|nil): List of LSP - `CodeActionKind`s used to filter the code - actions. Most language servers support - values like `refactor` or `quickfix`. - - • filter: (function|nil) Predicate taking an - `CodeAction` and returning a boolean. - • apply: (boolean|nil) When set to `true`, and - there is just one remaining action (after - filtering), the action is applied without - user query. - • range: (table|nil) Range for which code - actions should be requested. If in visual - mode this defaults to the active selection. - Table must contain `start` and `end` keys - with {row, col} tuples using mark-like - indexing. See |api-indexing| - - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_codeAction + Selects a code action available at the current cursor position. + + Parameters: ~ + {options} (table|nil) Optional table which holds the following + optional fields: + • context: (table|nil) Corresponds to `CodeActionContext` of the LSP specification: + • diagnostics (table|nil): LSP`Diagnostic[]` . Inferred from the current position if not provided. + • only (table|nil): List of LSP `CodeActionKind`s used to + filter the code actions. Most language servers support + values like `refactor` or `quickfix`. + + • filter: (function|nil) Predicate taking an `CodeAction` + and returning a boolean. + • apply: (boolean|nil) When set to `true`, and there is + just one remaining action (after filtering), the action + is applied without user query. + • range: (table|nil) Range for which code actions should be + requested. If in visual mode this defaults to the active + selection. Table must contain `start` and `end` keys with + {row, col} tuples using mark-like indexing. See + |api-indexing| + + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_codeAction completion({context}) *vim.lsp.buf.completion()* - Retrieves the completion items at the current cursor position. - Can only be called in Insert mode. + Retrieves the completion items at the current cursor position. Can only be + called in Insert mode. - Parameters: ~ - {context} (context support not yet implemented) - Additional information about the context in - which a completion was triggered (how it was - triggered, and by which trigger character, if - applicable) + Parameters: ~ + {context} (context support not yet implemented) Additional + information about the context in which a completion was + triggered (how it was triggered, and by which trigger + character, if applicable) - See also: ~ - |vim.lsp.protocol.constants.CompletionTriggerKind| + See also: ~ + |vim.lsp.protocol.constants.CompletionTriggerKind| declaration({options}) *vim.lsp.buf.declaration()* - Jumps to the declaration of the symbol under the cursor. - Note: - Many servers do not implement this method. Generally, see - |vim.lsp.buf.definition()| instead. - - Parameters: ~ - {options} (table|nil) additional options - • reuse_win: (boolean) Jump to existing window - if buffer is already open. - • on_list: (function) handler for list results. - See |on-list-handler| + Jumps to the declaration of the symbol under the cursor. + Note: + Many servers do not implement this method. Generally, see + |vim.lsp.buf.definition()| instead. + + Parameters: ~ + {options} (table|nil) additional options + • reuse_win: (boolean) Jump to existing window if buffer is + already open. + • on_list: (function) handler for list results. See + |on-list-handler| definition({options}) *vim.lsp.buf.definition()* - Jumps to the definition of the symbol under the cursor. + Jumps to the definition of the symbol under the cursor. - Parameters: ~ - {options} (table|nil) additional options - • reuse_win: (boolean) Jump to existing window - if buffer is already open. - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {options} (table|nil) additional options + • reuse_win: (boolean) Jump to existing window if buffer is + already open. + • on_list: (function) handler for list results. See + |on-list-handler| document_highlight() *vim.lsp.buf.document_highlight()* - Send request to the server to resolve document highlights for - the current text document position. This request can be - triggered by a key mapping or by events such as `CursorHold`, - e.g.: + Send request to the server to resolve document highlights for the current + text document position. This request can be triggered by a key mapping or + by events such as `CursorHold`, e.g.: > autocmd CursorHold lua vim.lsp.buf.document_highlight() autocmd CursorHoldI lua vim.lsp.buf.document_highlight() autocmd CursorMoved lua vim.lsp.buf.clear_references() < - Note: Usage of |vim.lsp.buf.document_highlight()| requires the - following highlight groups to be defined or you won't be able - to see the actual highlights. |LspReferenceText| - |LspReferenceRead| |LspReferenceWrite| + Note: Usage of |vim.lsp.buf.document_highlight()| requires the following + highlight groups to be defined or you won't be able to see the actual + highlights. |LspReferenceText| |LspReferenceRead| |LspReferenceWrite| document_symbol({options}) *vim.lsp.buf.document_symbol()* - Lists all symbols in the current buffer in the quickfix - window. + Lists all symbols in the current buffer in the quickfix window. - Parameters: ~ - {options} (table|nil) additional options - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {options} (table|nil) additional options + • on_list: (function) handler for list results. See + |on-list-handler| execute_command({command_params}) *vim.lsp.buf.execute_command()* - Executes an LSP server command. + Executes an LSP server command. - Parameters: ~ - {command_params} (table) A valid `ExecuteCommandParams` - object + Parameters: ~ + {command_params} (table) A valid `ExecuteCommandParams` object - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand format({options}) *vim.lsp.buf.format()* - Formats a buffer using the attached (and optionally filtered) - language server clients. - - Parameters: ~ - {options} table|nil Optional table which holds the - following optional fields: - • formatting_options (table|nil): Can be used - to specify FormattingOptions. Some - unspecified options will be automatically - derived from the current Neovim options. See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#formattingOptions - • timeout_ms (integer|nil, default 1000): Time - in milliseconds to block for formatting - requests. No effect if async=true - • bufnr (number|nil): Restrict formatting to - the clients attached to the given buffer, - defaults to the current buffer (0). - • filter (function|nil): Predicate used to - filter clients. Receives a client as argument - and must return a boolean. Clients matching - the predicate are included. Example: • > - - -- Never request typescript-language-server for formatting - vim.lsp.buf.format { - filter = function(client) return client.name ~= "tsserver" end - } + Formats a buffer using the attached (and optionally filtered) language + server clients. + + Parameters: ~ + {options} table|nil Optional table which holds the following optional + fields: + • formatting_options (table|nil): Can be used to specify + FormattingOptions. Some unspecified options will be + automatically derived from the current Neovim options. + See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#formattingOptions + • timeout_ms (integer|nil, default 1000): Time in + milliseconds to block for formatting requests. No effect + if async=true + • bufnr (number|nil): Restrict formatting to the clients + attached to the given buffer, defaults to the current + buffer (0). + • filter (function|nil): Predicate used to filter clients. + Receives a client as argument and must return a boolean. + Clients matching the predicate are included. Example: • > + + -- Never request typescript-language-server for formatting + vim.lsp.buf.format { + filter = function(client) return client.name ~= "tsserver" end + } < - • async boolean|nil If true the method won't - block. Defaults to false. Editing the buffer - while formatting asynchronous can lead to - unexpected changes. - • id (number|nil): Restrict formatting to the - client with ID (client.id) matching this - field. - • name (string|nil): Restrict formatting to the - client with name (client.name) matching this - field. + • async boolean|nil If true the method won't block. + Defaults to false. Editing the buffer while formatting + asynchronous can lead to unexpected changes. + • id (number|nil): Restrict formatting to the client with + ID (client.id) matching this field. + • name (string|nil): Restrict formatting to the client with + name (client.name) matching this field. formatting({options}) *vim.lsp.buf.formatting()* - Formats the current buffer. + Formats the current buffer. - Parameters: ~ - {options} (table|nil) Can be used to specify - FormattingOptions. Some unspecified options - will be automatically derived from the current - Neovim options. + Parameters: ~ + {options} (table|nil) Can be used to specify FormattingOptions. Some + unspecified options will be automatically derived from the + current Neovim options. - See also: ~ - https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting + See also: ~ + https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting *vim.lsp.buf.formatting_seq_sync()* formatting_seq_sync({options}, {timeout_ms}, {order}) - Formats the current buffer by sequentially requesting - formatting from attached clients. + Formats the current buffer by sequentially requesting formatting from + attached clients. - Useful when multiple clients with formatting capability are - attached. + Useful when multiple clients with formatting capability are attached. - Since it's synchronous, can be used for running on save, to - make sure buffer is formatted prior to being saved. - {timeout_ms} is passed on to the |vim.lsp.client| `request_sync` method. Example: > + Since it's synchronous, can be used for running on save, to make sure + buffer is formatted prior to being saved. {timeout_ms} is passed on to the + |vim.lsp.client| `request_sync` method. Example: > - vim.api.nvim_command[[autocmd BufWritePre lua vim.lsp.buf.formatting_seq_sync()]] + vim.api.nvim_command[[autocmd BufWritePre lua vim.lsp.buf.formatting_seq_sync()]] < - Parameters: ~ - {options} (table|nil) `FormattingOptions` entries - {timeout_ms} (number|nil) Request timeout - {order} (table|nil) List of client names. Formatting - is requested from clients in the following - order: first all clients that are not in the - `order` list, then the remaining clients in - the order as they occur in the `order` list. + Parameters: ~ + {options} (table|nil) `FormattingOptions` entries + {timeout_ms} (number|nil) Request timeout + {order} (table|nil) List of client names. Formatting is + requested from clients in the following order: first all + clients that are not in the `order` list, then the + remaining clients in the order as they occur in the + `order` list. *vim.lsp.buf.formatting_sync()* formatting_sync({options}, {timeout_ms}) - Performs |vim.lsp.buf.formatting()| synchronously. + Performs |vim.lsp.buf.formatting()| synchronously. - Useful for running on save, to make sure buffer is formatted - prior to being saved. {timeout_ms} is passed on to - |vim.lsp.buf_request_sync()|. Example: + Useful for running on save, to make sure buffer is formatted prior to + being saved. {timeout_ms} is passed on to |vim.lsp.buf_request_sync()|. + Example: > autocmd BufWritePre lua vim.lsp.buf.formatting_sync() < - Parameters: ~ - {options} (table|nil) with valid `FormattingOptions` - entries - {timeout_ms} (number) Request timeout + Parameters: ~ + {options} (table|nil) with valid `FormattingOptions` entries + {timeout_ms} (number) Request timeout - See also: ~ - |vim.lsp.buf.formatting_seq_sync| + See also: ~ + |vim.lsp.buf.formatting_seq_sync| hover() *vim.lsp.buf.hover()* - Displays hover information about the symbol under the cursor - in a floating window. Calling the function twice will jump - into the floating window. + Displays hover information about the symbol under the cursor in a floating + window. Calling the function twice will jump into the floating window. implementation({options}) *vim.lsp.buf.implementation()* - Lists all the implementations for the symbol under the cursor - in the quickfix window. + Lists all the implementations for the symbol under the cursor in the + quickfix window. - Parameters: ~ - {options} (table|nil) additional options - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {options} (table|nil) additional options + • on_list: (function) handler for list results. See + |on-list-handler| incoming_calls() *vim.lsp.buf.incoming_calls()* - Lists all the call sites of the symbol under the cursor in the - |quickfix| window. If the symbol can resolve to multiple - items, the user can pick one in the |inputlist|. + Lists all the call sites of the symbol under the cursor in the |quickfix| + window. If the symbol can resolve to multiple items, the user can pick one + in the |inputlist|. list_workspace_folders() *vim.lsp.buf.list_workspace_folders()* - List workspace folders. + List workspace folders. outgoing_calls() *vim.lsp.buf.outgoing_calls()* - Lists all the items that are called by the symbol under the - cursor in the |quickfix| window. If the symbol can resolve to - multiple items, the user can pick one in the |inputlist|. + Lists all the items that are called by the symbol under the cursor in the + |quickfix| window. If the symbol can resolve to multiple items, the user + can pick one in the |inputlist|. *vim.lsp.buf.range_code_action()* range_code_action({context}, {start_pos}, {end_pos}) - Performs |vim.lsp.buf.code_action()| for a given range. - - Parameters: ~ - {context} (table|nil) `CodeActionContext` of the LSP specification: - • diagnostics: (table|nil) LSP`Diagnostic[]` . Inferred from the current position if not - provided. - • only: (table|nil) List of LSP - `CodeActionKind`s used to filter the code - actions. Most language servers support - values like `refactor` or `quickfix`. - {start_pos} ({number, number}, optional) mark-indexed - position. Defaults to the start of the last - visual selection. - {end_pos} ({number, number}, optional) mark-indexed - position. Defaults to the end of the last - visual selection. + Performs |vim.lsp.buf.code_action()| for a given range. + + Parameters: ~ + {context} (table|nil) `CodeActionContext` of the LSP specification: + • diagnostics: (table|nil) LSP`Diagnostic[]` . Inferred from the current position if not provided. + • only: (table|nil) List of LSP `CodeActionKind`s used to + filter the code actions. Most language servers support + values like `refactor` or `quickfix`. + {start_pos} ({number, number}, optional) mark-indexed position. + Defaults to the start of the last visual selection. + {end_pos} ({number, number}, optional) mark-indexed position. + Defaults to the end of the last visual selection. *vim.lsp.buf.range_formatting()* range_formatting({options}, {start_pos}, {end_pos}) - Formats a given range. + Formats a given range. - Parameters: ~ - {options} Table with valid `FormattingOptions` entries. - {start_pos} ({number, number}, optional) mark-indexed - position. Defaults to the start of the last - visual selection. - {end_pos} ({number, number}, optional) mark-indexed - position. Defaults to the end of the last - visual selection. + Parameters: ~ + {options} Table with valid `FormattingOptions` entries. + {start_pos} ({number, number}, optional) mark-indexed position. + Defaults to the start of the last visual selection. + {end_pos} ({number, number}, optional) mark-indexed position. + Defaults to the end of the last visual selection. references({context}, {options}) *vim.lsp.buf.references()* - Lists all the references to the symbol under the cursor in the - quickfix window. + Lists all the references to the symbol under the cursor in the quickfix + window. - Parameters: ~ - {context} (table) Context for the request - {options} (table|nil) additional options - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {context} (table) Context for the request + {options} (table|nil) additional options + • on_list: (function) handler for list results. See + |on-list-handler| - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references *vim.lsp.buf.remove_workspace_folder()* remove_workspace_folder({workspace_folder}) - Remove the folder at path from the workspace folders. If - {path} is not provided, the user will be prompted for a path - using |input()|. + Remove the folder at path from the workspace folders. If {path} is not + provided, the user will be prompted for a path using |input()|. rename({new_name}, {options}) *vim.lsp.buf.rename()* - Renames all references to the symbol under the cursor. - - Parameters: ~ - {new_name} (string|nil) If not provided, the user will be - prompted for a new name using - |vim.ui.input()|. - {options} (table|nil) additional options - • filter (function|nil): Predicate used to - filter clients. Receives a client as - argument and must return a boolean. Clients - matching the predicate are included. - • name (string|nil): Restrict clients used for - rename to ones where client.name matches - this field. + Renames all references to the symbol under the cursor. + + Parameters: ~ + {new_name} (string|nil) If not provided, the user will be prompted + for a new name using |vim.ui.input()|. + {options} (table|nil) additional options + • filter (function|nil): Predicate used to filter clients. + Receives a client as argument and must return a boolean. + Clients matching the predicate are included. + • name (string|nil): Restrict clients used for rename to + ones where client.name matches this field. server_ready() *vim.lsp.buf.server_ready()* - Checks whether the language servers attached to the current - buffer are ready. + Checks whether the language servers attached to the current buffer are + ready. - Return: ~ - `true` if server responds. + Return: ~ + `true` if server responds. signature_help() *vim.lsp.buf.signature_help()* - Displays signature information about the symbol under the - cursor in a floating window. + Displays signature information about the symbol under the cursor in a + floating window. type_definition({options}) *vim.lsp.buf.type_definition()* - Jumps to the definition of the type of the symbol under the - cursor. + Jumps to the definition of the type of the symbol under the cursor. - Parameters: ~ - {options} (table|nil) additional options - • reuse_win: (boolean) Jump to existing window - if buffer is already open. - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {options} (table|nil) additional options + • reuse_win: (boolean) Jump to existing window if buffer is + already open. + • on_list: (function) handler for list results. See + |on-list-handler| workspace_symbol({query}, {options}) *vim.lsp.buf.workspace_symbol()* - Lists all symbols in the current workspace in the quickfix - window. + Lists all symbols in the current workspace in the quickfix window. - The list is filtered against {query}; if the argument is - omitted from the call, the user is prompted to enter a string - on the command line. An empty string means no filtering is - done. + The list is filtered against {query}; if the argument is omitted from the + call, the user is prompted to enter a string on the command line. An empty + string means no filtering is done. - Parameters: ~ - {query} (string, optional) - {options} (table|nil) additional options - • on_list: (function) handler for list results. - See |on-list-handler| + Parameters: ~ + {query} (string, optional) + {options} (table|nil) additional options + • on_list: (function) handler for list results. See + |on-list-handler| ============================================================================== Lua module: vim.lsp.diagnostic *lsp-diagnostic* get_namespace({client_id}) *vim.lsp.diagnostic.get_namespace()* - Get the diagnostic namespace associated with an LSP client - |vim.diagnostic|. + Get the diagnostic namespace associated with an LSP client + |vim.diagnostic|. - Parameters: ~ - {client_id} (number) The id of the LSP client + Parameters: ~ + {client_id} (number) The id of the LSP client *vim.lsp.diagnostic.on_publish_diagnostics()* on_publish_diagnostics({_}, {result}, {ctx}, {config}) - |lsp-handler| for the method "textDocument/publishDiagnostics" - - See |vim.diagnostic.config()| for configuration options. - Handler-specific configuration can be set using - |vim.lsp.with()|: > - - vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( - vim.lsp.diagnostic.on_publish_diagnostics, { - -- Enable underline, use default values - underline = true, - -- Enable virtual text, override spacing to 4 - virtual_text = { - spacing = 4, - }, - -- Use a function to dynamically turn signs off - -- and on, using buffer local variables - signs = function(namespace, bufnr) - return vim.b[bufnr].show_signs == true - end, - -- Disable a feature - update_in_insert = false, - } - ) + |lsp-handler| for the method "textDocument/publishDiagnostics" + + See |vim.diagnostic.config()| for configuration options. Handler-specific + configuration can be set using |vim.lsp.with()|: > + + vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( + vim.lsp.diagnostic.on_publish_diagnostics, { + -- Enable underline, use default values + underline = true, + -- Enable virtual text, override spacing to 4 + virtual_text = { + spacing = 4, + }, + -- Use a function to dynamically turn signs off + -- and on, using buffer local variables + signs = function(namespace, bufnr) + return vim.b[bufnr].show_signs == true + end, + -- Disable a feature + update_in_insert = false, + } + ) < - Parameters: ~ - {config} (table) Configuration table (see - |vim.diagnostic.config()|). + Parameters: ~ + {config} (table) Configuration table (see |vim.diagnostic.config()|). ============================================================================== Lua module: vim.lsp.codelens *lsp-codelens* display({lenses}, {bufnr}, {client_id}) *vim.lsp.codelens.display()* - Display the lenses using virtual text + Display the lenses using virtual text - Parameters: ~ - {lenses} (table) of lenses to display (`CodeLens[] | - null`) - {bufnr} (number) - {client_id} (number) + Parameters: ~ + {lenses} (table) of lenses to display (`CodeLens[] | null`) + {bufnr} (number) + {client_id} (number) get({bufnr}) *vim.lsp.codelens.get()* - Return all lenses for the given buffer + Return all lenses for the given buffer - Parameters: ~ - {bufnr} (number) Buffer number. 0 can be used for the - current buffer. + Parameters: ~ + {bufnr} (number) Buffer number. 0 can be used for the current buffer. - Return: ~ - (table) (`CodeLens[]`) + Return: ~ + (table) (`CodeLens[]`) *vim.lsp.codelens.on_codelens()* on_codelens({err}, {result}, {ctx}, {_}) - |lsp-handler| for the method `textDocument/codeLens` + |lsp-handler| for the method `textDocument/codeLens` refresh() *vim.lsp.codelens.refresh()* - Refresh the codelens for the current buffer + Refresh the codelens for the current buffer - It is recommended to trigger this using an autocmd or via - keymap. + It is recommended to trigger this using an autocmd or via keymap. > autocmd BufEnter,CursorHold,InsertLeave lua vim.lsp.codelens.refresh() < run() *vim.lsp.codelens.run()* - Run the code lens in the current line + Run the code lens in the current line save({lenses}, {bufnr}, {client_id}) *vim.lsp.codelens.save()* - Store lenses for a specific buffer and client + Store lenses for a specific buffer and client - Parameters: ~ - {lenses} (table) of lenses to store (`CodeLens[] | - null`) - {bufnr} (number) - {client_id} (number) + Parameters: ~ + {lenses} (table) of lenses to store (`CodeLens[] | null`) + {bufnr} (number) + {client_id} (number) ============================================================================== Lua module: vim.lsp.handlers *lsp-handlers* hover({_}, {result}, {ctx}, {config}) *vim.lsp.handlers.hover()* - |lsp-handler| for the method "textDocument/hover" > - - vim.lsp.handlers["textDocument/hover"] = vim.lsp.with( - vim.lsp.handlers.hover, { - -- Use a sharp border with `FloatBorder` highlights - border = "single" - } - ) + |lsp-handler| for the method "textDocument/hover" > + + vim.lsp.handlers["textDocument/hover"] = vim.lsp.with( + vim.lsp.handlers.hover, { + -- Use a sharp border with `FloatBorder` highlights + border = "single" + } + ) < - Parameters: ~ - {config} (table) Configuration table. - • border: (default=nil) - • Add borders to the floating window - • See |nvim_open_win()| + Parameters: ~ + {config} (table) Configuration table. + • border: (default=nil) + • Add borders to the floating window + • See |nvim_open_win()| *vim.lsp.handlers.signature_help()* signature_help({_}, {result}, {ctx}, {config}) - |lsp-handler| for the method "textDocument/signatureHelp". The - active parameter is highlighted with - |hl-LspSignatureActiveParameter|. > - - vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with( - vim.lsp.handlers.signature_help, { - -- Use a sharp border with `FloatBorder` highlights - border = "single" - } - ) + |lsp-handler| for the method "textDocument/signatureHelp". The active + parameter is highlighted with |hl-LspSignatureActiveParameter|. > + + vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with( + vim.lsp.handlers.signature_help, { + -- Use a sharp border with `FloatBorder` highlights + border = "single" + } + ) < - Parameters: ~ - {config} (table) Configuration table. - • border: (default=nil) - • Add borders to the floating window - • See |vim.api.nvim_open_win()| + Parameters: ~ + {config} (table) Configuration table. + • border: (default=nil) + • Add borders to the floating window + • See |vim.api.nvim_open_win()| ============================================================================== @@ -1558,591 +1447,543 @@ Lua module: vim.lsp.util *lsp-util* *vim.lsp.util.apply_text_document_edit()* apply_text_document_edit({text_document_edit}, {index}, {offset_encoding}) - Applies a `TextDocumentEdit`, which is a list of changes to a - single document. + Applies a `TextDocumentEdit`, which is a list of changes to a single + document. - Parameters: ~ - {text_document_edit} table: a `TextDocumentEdit` object - {index} number: Optional index of the edit, - if from a list of edits (or nil, if - not from a list) + Parameters: ~ + {text_document_edit} table: a `TextDocumentEdit` object + {index} number: Optional index of the edit, if from a + list of edits (or nil, if not from a list) - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentEdit + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentEdit *vim.lsp.util.apply_text_edits()* apply_text_edits({text_edits}, {bufnr}, {offset_encoding}) - Applies a list of text edits to a buffer. + Applies a list of text edits to a buffer. - Parameters: ~ - {text_edits} (table) list of `TextEdit` objects - {bufnr} (number) Buffer id - {offset_encoding} (string) utf-8|utf-16|utf-32 + Parameters: ~ + {text_edits} (table) list of `TextEdit` objects + {bufnr} (number) Buffer id + {offset_encoding} (string) utf-8|utf-16|utf-32 - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit *vim.lsp.util.apply_workspace_edit()* apply_workspace_edit({workspace_edit}, {offset_encoding}) - Applies a `WorkspaceEdit`. + Applies a `WorkspaceEdit`. - Parameters: ~ - {workspace_edit} (table) `WorkspaceEdit` - {offset_encoding} (string) utf-8|utf-16|utf-32 (required) + Parameters: ~ + {workspace_edit} (table) `WorkspaceEdit` + {offset_encoding} (string) utf-8|utf-16|utf-32 (required) buf_clear_references({bufnr}) *vim.lsp.util.buf_clear_references()* - Removes document highlights from a buffer. + Removes document highlights from a buffer. - Parameters: ~ - {bufnr} (number) Buffer id + Parameters: ~ + {bufnr} (number) Buffer id *vim.lsp.util.buf_highlight_references()* buf_highlight_references({bufnr}, {references}, {offset_encoding}) - Shows a list of document highlights for a certain buffer. + Shows a list of document highlights for a certain buffer. - Parameters: ~ - {bufnr} (number) Buffer id - {references} (table) List of `DocumentHighlight` - objects to highlight - {offset_encoding} (string) One of "utf-8", "utf-16", - "utf-32". + Parameters: ~ + {bufnr} (number) Buffer id + {references} (table) List of `DocumentHighlight` objects to + highlight + {offset_encoding} (string) One of "utf-8", "utf-16", "utf-32". - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#documentHighlight + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#documentHighlight *vim.lsp.util.character_offset()* character_offset({buf}, {row}, {col}, {offset_encoding}) - Returns the UTF-32 and UTF-16 offsets for a position in a - certain buffer. + Returns the UTF-32 and UTF-16 offsets for a position in a certain buffer. - Parameters: ~ - {buf} (number) buffer number (0 for current) - {row} 0-indexed line - {col} 0-indexed byte offset in line - {offset_encoding} (string) utf-8|utf-16|utf-32|nil - defaults to `offset_encoding` of first - client of `buf` + Parameters: ~ + {buf} (number) buffer number (0 for current) + {row} 0-indexed line + {col} 0-indexed byte offset in line + {offset_encoding} (string) utf-8|utf-16|utf-32|nil defaults to + `offset_encoding` of first client of `buf` - Return: ~ - (number, number) `offset_encoding` index of the character - in line {row} column {col} in buffer {buf} + Return: ~ + (number, number) `offset_encoding` index of the character in line + {row} column {col} in buffer {buf} *vim.lsp.util.convert_input_to_markdown_lines()* convert_input_to_markdown_lines({input}, {contents}) - Converts any of `MarkedString` | `MarkedString[]` | - `MarkupContent` into a list of lines containing valid - markdown. Useful to populate the hover window for - `textDocument/hover`, for parsing the result of - `textDocument/signatureHelp`, and potentially others. + Converts any of `MarkedString` | `MarkedString[]` | `MarkupContent` into a + list of lines containing valid markdown. Useful to populate the hover + window for `textDocument/hover`, for parsing the result of + `textDocument/signatureHelp`, and potentially others. - Parameters: ~ - {input} (`MarkedString` | `MarkedString[]` | - `MarkupContent`) - {contents} (table, optional, default `{}`) List of - strings to extend with converted lines + Parameters: ~ + {input} (`MarkedString` | `MarkedString[]` | `MarkupContent`) + {contents} (table, optional, default `{}`) List of strings to extend + with converted lines - Return: ~ - {contents}, extended with lines of converted markdown. + Return: ~ + {contents}, extended with lines of converted markdown. - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover *vim.lsp.util.convert_signature_help_to_markdown_lines()* convert_signature_help_to_markdown_lines({signature_help}, {ft}, {triggers}) - Converts `textDocument/SignatureHelp` response to markdown - lines. + Converts `textDocument/SignatureHelp` response to markdown lines. - Parameters: ~ - {signature_help} Response of `textDocument/SignatureHelp` - {ft} optional filetype that will be use as - the `lang` for the label markdown code - block - {triggers} optional list of trigger characters from - the lsp server. used to better determine - parameter offsets + Parameters: ~ + {signature_help} Response of `textDocument/SignatureHelp` + {ft} optional filetype that will be use as the `lang` for + the label markdown code block + {triggers} optional list of trigger characters from the lsp + server. used to better determine parameter offsets - Return: ~ - list of lines of converted markdown. + Return: ~ + list of lines of converted markdown. - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_signatureHelp + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_signatureHelp *vim.lsp.util.extract_completion_items()* extract_completion_items({result}) - Can be used to extract the completion items from a `textDocument/completion` request, which may return one of `CompletionItem[]` , `CompletionList` or null. + Can be used to extract the completion items from a `textDocument/completion` request, which may return one of `CompletionItem[]` , `CompletionList` or null. - Parameters: ~ - {result} (table) The result of a - `textDocument/completion` request + Parameters: ~ + {result} (table) The result of a `textDocument/completion` request - Return: ~ - (table) List of completion items + Return: ~ + (table) List of completion items - See also: ~ - https://microsoft.github.io/language-server-protocol/specification#textDocument_completion + See also: ~ + https://microsoft.github.io/language-server-protocol/specification#textDocument_completion get_effective_tabstop({bufnr}) *vim.lsp.util.get_effective_tabstop()* - Returns indentation size. + Returns indentation size. - Parameters: ~ - {bufnr} (number|nil): Buffer handle, defaults to current + Parameters: ~ + {bufnr} (number|nil): Buffer handle, defaults to current - Return: ~ - (number) indentation size + Return: ~ + (number) indentation size - See also: ~ - |shiftwidth| + See also: ~ + |shiftwidth| *vim.lsp.util.jump_to_location()* jump_to_location({location}, {offset_encoding}, {reuse_win}) - Jumps to a location. + Jumps to a location. - Parameters: ~ - {location} (table) (`Location`|`LocationLink`) - {offset_encoding} (string) utf-8|utf-16|utf-32 (required) - {reuse_win} (boolean) Jump to existing window if - buffer is already opened. + Parameters: ~ + {location} (table) (`Location`|`LocationLink`) + {offset_encoding} (string) utf-8|utf-16|utf-32 (required) + {reuse_win} (boolean) Jump to existing window if buffer is + already opened. - Return: ~ - `true` if the jump succeeded + Return: ~ + `true` if the jump succeeded *vim.lsp.util.locations_to_items()* locations_to_items({locations}, {offset_encoding}) - Returns the items with the byte position calculated correctly - and in sorted order, for display in quickfix and location - lists. + Returns the items with the byte position calculated correctly and in + sorted order, for display in quickfix and location lists. - The result can be passed to the {list} argument of - |setqflist()| or |setloclist()|. + The result can be passed to the {list} argument of |setqflist()| or + |setloclist()|. - Parameters: ~ - {locations} (table) list of `Location`s or - `LocationLink`s - {offset_encoding} (string) offset_encoding for locations - utf-8|utf-16|utf-32 + Parameters: ~ + {locations} (table) list of `Location`s or `LocationLink`s + {offset_encoding} (string) offset_encoding for locations + utf-8|utf-16|utf-32 - Return: ~ - (table) list of items + Return: ~ + (table) list of items lookup_section({settings}, {section}) *vim.lsp.util.lookup_section()* - Helper function to return nested values in language server - settings + Helper function to return nested values in language server settings - Parameters: ~ - {settings} a table of language server settings - {section} a string indicating the field of the settings - table + Parameters: ~ + {settings} a table of language server settings + {section} a string indicating the field of the settings table - Return: ~ - (table or string) The value of settings accessed via - section + Return: ~ + (table or string) The value of settings accessed via section *vim.lsp.util.make_floating_popup_options()* make_floating_popup_options({width}, {height}, {opts}) - Creates a table with sensible default options for a floating - window. The table can be passed to |nvim_open_win()|. - - Parameters: ~ - {width} (number) window width (in character cells) - {height} (number) window height (in character cells) - {opts} (table, optional) - • offset_x (number) offset to add to `col` - • offset_y (number) offset to add to `row` - • border (string or table) override `border` - • focusable (string or table) override - `focusable` - • zindex (string or table) override `zindex`, - defaults to 50 - - Return: ~ - (table) Options + Creates a table with sensible default options for a floating window. The + table can be passed to |nvim_open_win()|. + + Parameters: ~ + {width} (number) window width (in character cells) + {height} (number) window height (in character cells) + {opts} (table, optional) + • offset_x (number) offset to add to `col` + • offset_y (number) offset to add to `row` + • border (string or table) override `border` + • focusable (string or table) override `focusable` + • zindex (string or table) override `zindex`, defaults to 50 + + Return: ~ + (table) Options *vim.lsp.util.make_formatting_params()* make_formatting_params({options}) - Creates a `DocumentFormattingParams` object for the current - buffer and cursor position. + Creates a `DocumentFormattingParams` object for the current buffer and + cursor position. - Parameters: ~ - {options} (table|nil) with valid `FormattingOptions` - entries + Parameters: ~ + {options} (table|nil) with valid `FormattingOptions` entries - Return: ~ - `DocumentFormattingParams` object + Return: ~ + `DocumentFormattingParams` object - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_formatting + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_formatting *vim.lsp.util.make_given_range_params()* make_given_range_params({start_pos}, {end_pos}, {bufnr}, {offset_encoding}) - Using the given range in the current buffer, creates an object - that is similar to |vim.lsp.util.make_range_params()|. - - Parameters: ~ - {start_pos} number[]|nil {row, col} mark-indexed - position. Defaults to the start of the - last visual selection. - {end_pos} number[]|nil {row, col} mark-indexed - position. Defaults to the end of the - last visual selection. - {bufnr} (number|nil) buffer handle or 0 for - current, defaults to current - {offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults - to `offset_encoding` of first client of - `bufnr` - - Return: ~ - { textDocument = { uri = `current_file_uri` }, range = { - start = `start_position`, end = `end_position` } } + Using the given range in the current buffer, creates an object that is + similar to |vim.lsp.util.make_range_params()|. + + Parameters: ~ + {start_pos} number[]|nil {row, col} mark-indexed position. + Defaults to the start of the last visual selection. + {end_pos} number[]|nil {row, col} mark-indexed position. + Defaults to the end of the last visual selection. + {bufnr} (number|nil) buffer handle or 0 for current, + defaults to current + {offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults to + `offset_encoding` of first client of `bufnr` + + Return: ~ + { textDocument = { uri = `current_file_uri` }, range = { start = + `start_position`, end = `end_position` } } *vim.lsp.util.make_position_params()* make_position_params({window}, {offset_encoding}) - Creates a `TextDocumentPositionParams` object for the current - buffer and cursor position. + Creates a `TextDocumentPositionParams` object for the current buffer and + cursor position. - Parameters: ~ - {window} number|nil: window handle or 0 for - current, defaults to current - {offset_encoding} (string) utf-8|utf-16|utf-32|nil - defaults to `offset_encoding` of first - client of buffer of `window` + Parameters: ~ + {window} number|nil: window handle or 0 for current, + defaults to current + {offset_encoding} (string) utf-8|utf-16|utf-32|nil defaults to + `offset_encoding` of first client of buffer of + `window` - Return: ~ - `TextDocumentPositionParams` object + Return: ~ + `TextDocumentPositionParams` object - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentPositionParams + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentPositionParams *vim.lsp.util.make_range_params()* make_range_params({window}, {offset_encoding}) - Using the current position in the current buffer, creates an - object that can be used as a building block for several LSP - requests, such as `textDocument/codeAction`, - `textDocument/colorPresentation`, - `textDocument/rangeFormatting`. - - Parameters: ~ - {window} number|nil: window handle or 0 for - current, defaults to current - {offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults - to `offset_encoding` of first client of - buffer of `window` - - Return: ~ - { textDocument = { uri = `current_file_uri` }, range = { - start = `current_position`, end = `current_position` } } + Using the current position in the current buffer, creates an object that + can be used as a building block for several LSP requests, such as + `textDocument/codeAction`, `textDocument/colorPresentation`, + `textDocument/rangeFormatting`. + + Parameters: ~ + {window} number|nil: window handle or 0 for current, + defaults to current + {offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults to + `offset_encoding` of first client of buffer of + `window` + + Return: ~ + { textDocument = { uri = `current_file_uri` }, range = { start = + `current_position`, end = `current_position` } } *vim.lsp.util.make_text_document_params()* make_text_document_params({bufnr}) - Creates a `TextDocumentIdentifier` object for the current - buffer. + Creates a `TextDocumentIdentifier` object for the current buffer. - Parameters: ~ - {bufnr} number|nil: Buffer handle, defaults to current + Parameters: ~ + {bufnr} number|nil: Buffer handle, defaults to current - Return: ~ - `TextDocumentIdentifier` + Return: ~ + `TextDocumentIdentifier` - See also: ~ - https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentIdentifier + See also: ~ + https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentIdentifier *vim.lsp.util.make_workspace_params()* make_workspace_params({added}, {removed}) - Create the workspace params + Create the workspace params - Parameters: ~ - {added} - {removed} + Parameters: ~ + {added} + {removed} *vim.lsp.util.open_floating_preview()* open_floating_preview({contents}, {syntax}, {opts}) - Shows contents in a floating window. - - Parameters: ~ - {contents} (table) of lines to show in window - {syntax} (string) of syntax to set for opened buffer - {opts} (table) with optional fields (additional keys - are passed on to |vim.api.nvim_open_win()|) - • height: (number) height of floating window - • width: (number) width of floating window - • wrap: (boolean, default true) wrap long - lines - • wrap_at: (number) character to wrap at for - computing height when wrap is enabled - • max_width: (number) maximal width of - floating window - • max_height: (number) maximal height of - floating window - • pad_top: (number) number of lines to pad - contents at top - • pad_bottom: (number) number of lines to pad - contents at bottom - • focus_id: (string) if a popup with this id - is opened, then focus it - • close_events: (table) list of events that - closes the floating window - • focusable: (boolean, default true) Make - float focusable - • focus: (boolean, default true) If `true`, - and if {focusable} is also `true`, focus an - existing floating window with the same - {focus_id} - - Return: ~ - bufnr,winnr buffer and window number of the newly created - floating preview window + Shows contents in a floating window. + + Parameters: ~ + {contents} (table) of lines to show in window + {syntax} (string) of syntax to set for opened buffer + {opts} (table) with optional fields (additional keys are passed + on to |vim.api.nvim_open_win()|) + • height: (number) height of floating window + • width: (number) width of floating window + • wrap: (boolean, default true) wrap long lines + • wrap_at: (number) character to wrap at for computing + height when wrap is enabled + • max_width: (number) maximal width of floating window + • max_height: (number) maximal height of floating window + • pad_top: (number) number of lines to pad contents at top + • pad_bottom: (number) number of lines to pad contents at + bottom + • focus_id: (string) if a popup with this id is opened, + then focus it + • close_events: (table) list of events that closes the + floating window + • focusable: (boolean, default true) Make float focusable + • focus: (boolean, default true) If `true`, and if + {focusable} is also `true`, focus an existing floating + window with the same {focus_id} + + Return: ~ + bufnr,winnr buffer and window number of the newly created floating + preview window parse_snippet({input}) *vim.lsp.util.parse_snippet()* - Parses snippets in a completion entry. + Parses snippets in a completion entry. - Parameters: ~ - {input} (string) unparsed snippet + Parameters: ~ + {input} (string) unparsed snippet - Return: ~ - (string) parsed snippet + Return: ~ + (string) parsed snippet preview_location({location}, {opts}) *vim.lsp.util.preview_location()* - Previews a location in a floating window + Previews a location in a floating window - behavior depends on type of location: - • for Location, range is shown (e.g., function definition) - • for LocationLink, targetRange is shown (e.g., body of - function definition) + behavior depends on type of location: + • for Location, range is shown (e.g., function definition) + • for LocationLink, targetRange is shown (e.g., body of function + definition) - Parameters: ~ - {location} a single `Location` or `LocationLink` + Parameters: ~ + {location} a single `Location` or `LocationLink` - Return: ~ - (bufnr,winnr) buffer and window number of floating window - or nil + Return: ~ + (bufnr,winnr) buffer and window number of floating window or nil rename({old_fname}, {new_fname}, {opts}) *vim.lsp.util.rename()* - Rename old_fname to new_fname + Rename old_fname to new_fname - Parameters: ~ - {opts} (table) + Parameters: ~ + {opts} (table) set_lines({lines}, {A}, {B}, {new_lines}) *vim.lsp.util.set_lines()* - Replaces text in a range with new text. + Replaces text in a range with new text. - CAUTION: Changes in-place! + CAUTION: Changes in-place! - Parameters: ~ - {lines} (table) Original list of strings - {A} (table) Start position; a 2-tuple of {line, - col} numbers - {B} (table) End position; a 2-tuple of {line, - col} numbers - {new_lines} A list of strings to replace the original + Parameters: ~ + {lines} (table) Original list of strings + {A} (table) Start position; a 2-tuple of {line, col} numbers + {B} (table) End position; a 2-tuple of {line, col} numbers + {new_lines} A list of strings to replace the original - Return: ~ - (table) The modified {lines} object + Return: ~ + (table) The modified {lines} object *vim.lsp.util.stylize_markdown()* stylize_markdown({bufnr}, {contents}, {opts}) - Converts markdown into syntax highlighted regions by stripping - the code blocks and converting them into highlighted code. - This will by default insert a blank line separator after those - code block regions to improve readability. - - This method configures the given buffer and returns the lines - to set. - - If you want to open a popup with fancy markdown, use - `open_floating_preview` instead - - Parameters: ~ - {contents} (table) of lines to show in window - {opts} dictionary with optional fields - • height of floating window - • width of floating window - • wrap_at character to wrap at for computing - height - • max_width maximal width of floating window - • max_height maximal height of floating window - • pad_top number of lines to pad contents at - top - • pad_bottom number of lines to pad contents - at bottom - • separator insert separator after code block - - Return: ~ - width,height size of float + Converts markdown into syntax highlighted regions by stripping the code + blocks and converting them into highlighted code. This will by default + insert a blank line separator after those code block regions to improve + readability. + + This method configures the given buffer and returns the lines to set. + + If you want to open a popup with fancy markdown, use + `open_floating_preview` instead + + Parameters: ~ + {contents} (table) of lines to show in window + {opts} dictionary with optional fields + • height of floating window + • width of floating window + • wrap_at character to wrap at for computing height + • max_width maximal width of floating window + • max_height maximal height of floating window + • pad_top number of lines to pad contents at top + • pad_bottom number of lines to pad contents at bottom + • separator insert separator after code block + + Return: ~ + width,height size of float symbols_to_items({symbols}, {bufnr}) *vim.lsp.util.symbols_to_items()* - Converts symbols to quickfix list items. + Converts symbols to quickfix list items. - Parameters: ~ - {symbols} DocumentSymbol[] or SymbolInformation[] + Parameters: ~ + {symbols} DocumentSymbol[] or SymbolInformation[] *vim.lsp.util.text_document_completion_list_to_complete_items()* text_document_completion_list_to_complete_items({result}, {prefix}) - Turns the result of a `textDocument/completion` request into - vim-compatible |complete-items|. + Turns the result of a `textDocument/completion` request into + vim-compatible |complete-items|. - Parameters: ~ - {result} The result of a `textDocument/completion` call, - e.g. from |vim.lsp.buf.completion()|, which may - be one of `CompletionItem[]`, `CompletionList` - or `null` - {prefix} (string) the prefix to filter the completion - items + Parameters: ~ + {result} The result of a `textDocument/completion` call, e.g. from + |vim.lsp.buf.completion()|, which may be one of + `CompletionItem[]`, `CompletionList` or `null` + {prefix} (string) the prefix to filter the completion items - Return: ~ - { matches = complete-items table, incomplete = bool } + Return: ~ + { matches = complete-items table, incomplete = bool } - See also: ~ - |complete-items| + See also: ~ + |complete-items| trim_empty_lines({lines}) *vim.lsp.util.trim_empty_lines()* - Removes empty lines from the beginning and end. + Removes empty lines from the beginning and end. - Parameters: ~ - {lines} (table) list of lines to trim + Parameters: ~ + {lines} (table) list of lines to trim - Return: ~ - (table) trimmed list of lines + Return: ~ + (table) trimmed list of lines *vim.lsp.util.try_trim_markdown_code_blocks()* try_trim_markdown_code_blocks({lines}) - Accepts markdown lines and tries to reduce them to a filetype - if they comprise just a single code block. + Accepts markdown lines and tries to reduce them to a filetype if they + comprise just a single code block. - CAUTION: Modifies the input in-place! + CAUTION: Modifies the input in-place! - Parameters: ~ - {lines} (table) list of lines + Parameters: ~ + {lines} (table) list of lines - Return: ~ - (string) filetype or 'markdown' if it was unchanged. + Return: ~ + (string) filetype or 'markdown' if it was unchanged. ============================================================================== Lua module: vim.lsp.log *lsp-log* get_filename() *vim.lsp.log.get_filename()* - Returns the log filename. + Returns the log filename. - Return: ~ - (string) log filename + Return: ~ + (string) log filename get_level() *vim.lsp.log.get_level()* - Gets the current log level. + Gets the current log level. - Return: ~ - (string) current log level + Return: ~ + (string) current log level set_format_func({handle}) *vim.lsp.log.set_format_func()* - Sets formatting function used to format logs + Sets formatting function used to format logs - Parameters: ~ - {handle} (function) function to apply to logging - arguments, pass vim.inspect for multi-line - formatting + Parameters: ~ + {handle} (function) function to apply to logging arguments, pass + vim.inspect for multi-line formatting set_level({level}) *vim.lsp.log.set_level()* - Sets the current log level. + Sets the current log level. - Parameters: ~ - {level} (string or number) One of `vim.lsp.log.levels` + Parameters: ~ + {level} (string or number) One of `vim.lsp.log.levels` should_log({level}) *vim.lsp.log.should_log()* - Checks whether the level is sufficient for logging. + Checks whether the level is sufficient for logging. - Parameters: ~ - {level} (number) log level + Parameters: ~ + {level} (number) log level - Return: ~ - (bool) true if would log, false if not + Return: ~ + (bool) true if would log, false if not ============================================================================== Lua module: vim.lsp.rpc *lsp-rpc* format_rpc_error({err}) *vim.lsp.rpc.format_rpc_error()* - Constructs an error message from an LSP error object. + Constructs an error message from an LSP error object. - Parameters: ~ - {err} (table) The error object + Parameters: ~ + {err} (table) The error object - Return: ~ - (string) The formatted error message + Return: ~ + (string) The formatted error message notify({method}, {params}) *vim.lsp.rpc.notify()* - Sends a notification to the LSP server. + Sends a notification to the LSP server. - Parameters: ~ - {method} (string) The invoked LSP method - {params} (table): Parameters for the invoked LSP method + Parameters: ~ + {method} (string) The invoked LSP method + {params} (table): Parameters for the invoked LSP method - Return: ~ - (bool) `true` if notification could be sent, `false` if - not + Return: ~ + (bool) `true` if notification could be sent, `false` if not *vim.lsp.rpc.request()* request({method}, {params}, {callback}, {notify_reply_callback}) - Sends a request to the LSP server and runs {callback} upon - response. - - Parameters: ~ - {method} (string) The invoked LSP method - {params} (table) Parameters for the - invoked LSP method - {callback} (function) Callback to invoke - {notify_reply_callback} (function|nil) Callback to invoke - as soon as a request is no longer - pending - - Return: ~ - (bool, number) `(true, message_id)` if request could be - sent, `false` if not + Sends a request to the LSP server and runs {callback} upon response. + + Parameters: ~ + {method} (string) The invoked LSP method + {params} (table) Parameters for the invoked LSP method + {callback} (function) Callback to invoke + {notify_reply_callback} (function|nil) Callback to invoke as soon as + a request is no longer pending + + Return: ~ + (bool, number) `(true, message_id)` if request could be sent, `false` + if not *vim.lsp.rpc.rpc_response_error()* rpc_response_error({code}, {message}, {data}) - Creates an RPC response object/table. + Creates an RPC response object/table. - Parameters: ~ - {code} RPC error code defined in - `vim.lsp.protocol.ErrorCodes` - {message} (optional) arbitrary message to send to server - {data} (optional) arbitrary data to send to server + Parameters: ~ + {code} RPC error code defined in `vim.lsp.protocol.ErrorCodes` + {message} (optional) arbitrary message to send to server + {data} (optional) arbitrary data to send to server *vim.lsp.rpc.start()* start({cmd}, {cmd_args}, {dispatchers}, {extra_spawn_params}) - Starts an LSP server process and create an LSP RPC client - object to interact with it. Communication with the server is - currently limited to stdio. - - Parameters: ~ - {cmd} (string) Command to start the LSP - server. - {cmd_args} (table) List of additional string - arguments to pass to {cmd}. - {dispatchers} (table, optional) Dispatchers for - LSP message types. Valid dispatcher - names are: - • `"notification"` - • `"server_request"` - • `"on_error"` - • `"on_exit"` - {extra_spawn_params} (table, optional) Additional context - for the LSP server process. May - contain: - • {cwd} (string) Working directory - for the LSP server process - • {env} (table) Additional - environment variables for LSP - server process - - Return: ~ - Client RPC object. - Methods: - • `notify()` |vim.lsp.rpc.notify()| - • `request()` |vim.lsp.rpc.request()| - - Members: - • {pid} (number) The LSP server's PID. - • {handle} A handle for low-level interaction with the LSP - server process |vim.loop|. + Starts an LSP server process and create an LSP RPC client object to + interact with it. Communication with the server is currently limited to + stdio. + + Parameters: ~ + {cmd} (string) Command to start the LSP server. + {cmd_args} (table) List of additional string arguments to + pass to {cmd}. + {dispatchers} (table, optional) Dispatchers for LSP message + types. Valid dispatcher names are: + • `"notification"` + • `"server_request"` + • `"on_error"` + • `"on_exit"` + {extra_spawn_params} (table, optional) Additional context for the LSP + server process. May contain: + • {cwd} (string) Working directory for the LSP + server process + • {env} (table) Additional environment variables + for LSP server process + + Return: ~ + Client RPC object. + Methods: + • `notify()` |vim.lsp.rpc.notify()| + • `request()` |vim.lsp.rpc.request()| + + Members: + • {pid} (number) The LSP server's PID. + • {handle} A handle for low-level interaction with the LSP server + process |vim.loop|. ============================================================================== @@ -2150,23 +1991,20 @@ Lua module: vim.lsp.sync *lsp-sync* *vim.lsp.sync.compute_diff()* compute_diff({___MissingCloseParenHere___}) - Returns the range table for the difference between prev and - curr lines + Returns the range table for the difference between prev and curr lines - Parameters: ~ - {prev_lines} (table) list of lines - {curr_lines} (table) list of lines - {firstline} (number) line to begin search for first - difference - {lastline} (number) line to begin search in - old_lines for last difference - {new_lastline} (number) line to begin search in - new_lines for last difference - {offset_encoding} (string) encoding requested by language - server + Parameters: ~ + {prev_lines} (table) list of lines + {curr_lines} (table) list of lines + {firstline} (number) line to begin search for first difference + {lastline} (number) line to begin search in old_lines for last + difference + {new_lastline} (number) line to begin search in new_lines for last + difference + {offset_encoding} (string) encoding requested by language server - Return: ~ - (table) TextDocumentContentChangeEvent see https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocumentContentChangeEvent + Return: ~ + (table) TextDocumentContentChangeEvent see https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocumentContentChangeEvent ============================================================================== @@ -2174,19 +2012,18 @@ Lua module: vim.lsp.protocol *lsp-protocol* *vim.lsp.protocol.make_client_capabilities()* make_client_capabilities() - Gets a new ClientCapabilities object describing the LSP client - capabilities. + Gets a new ClientCapabilities object describing the LSP client + capabilities. *vim.lsp.protocol.resolve_capabilities()* resolve_capabilities({server_capabilities}) - Creates a normalized object describing LSP server - capabilities. + Creates a normalized object describing LSP server capabilities. - Parameters: ~ - {server_capabilities} (table) Table of capabilities - supported by the server + Parameters: ~ + {server_capabilities} (table) Table of capabilities supported by the + server - Return: ~ - (table) Normalized table of capabilities + Return: ~ + (table) Normalized table of capabilities - vim:tw=78:ts=8:ft=help:norl: + vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl: -- cgit From 8b67f37798d90da957801be791da9425fb6fe741 Mon Sep 17 00:00:00 2001 From: Mathias Fußenegger Date: Thu, 11 Aug 2022 15:17:05 +0200 Subject: fix(lsp): fix some type annotations in lsp.rpc (#19714) --- runtime/doc/lsp.txt | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 62b1dceb10..21026f2ef8 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -1947,9 +1947,10 @@ rpc_response_error({code}, {message}, {data}) Creates an RPC response object/table. Parameters: ~ - {code} RPC error code defined in `vim.lsp.protocol.ErrorCodes` - {message} (optional) arbitrary message to send to server - {data} (optional) arbitrary data to send to server + {code} (number) RPC error code defined in + `vim.lsp.protocol.ErrorCodes` + {message} (string|nil) arbitrary message to send to server + {data} any|nil arbitrary data to send to server *vim.lsp.rpc.start()* start({cmd}, {cmd_args}, {dispatchers}, {extra_spawn_params}) @@ -1961,13 +1962,13 @@ start({cmd}, {cmd_args}, {dispatchers}, {extra_spawn_params}) {cmd} (string) Command to start the LSP server. {cmd_args} (table) List of additional string arguments to pass to {cmd}. - {dispatchers} (table, optional) Dispatchers for LSP message - types. Valid dispatcher names are: + {dispatchers} (table|nil) Dispatchers for LSP message types. + Valid dispatcher names are: • `"notification"` • `"server_request"` • `"on_error"` • `"on_exit"` - {extra_spawn_params} (table, optional) Additional context for the LSP + {extra_spawn_params} (table|nil) Additional context for the LSP server process. May contain: • {cwd} (string) Working directory for the LSP server process -- cgit From 7a076306e4e35371160d1a5d09c92744b8461b57 Mon Sep 17 00:00:00 2001 From: Jonas Strittmatter <40792180+smjonas@users.noreply.github.com> Date: Wed, 17 Aug 2022 12:39:38 +0200 Subject: docs(lsp): rename on-list-handler to lsp-on-list-handler (#19813) This makes it easier to find documentation about the on-list-handler when starting the search term with "lsp". --- runtime/doc/lsp.txt | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 21026f2ef8..94aa42e500 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -415,7 +415,7 @@ For the format of the response message, see: For the format of the notification message, see: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage - *on-list-handler* + *lsp-on-list-handler* `on_list` receives a table with: @@ -1070,7 +1070,7 @@ declaration({options}) *vim.lsp.buf.declaration()* • reuse_win: (boolean) Jump to existing window if buffer is already open. • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| definition({options}) *vim.lsp.buf.definition()* Jumps to the definition of the symbol under the cursor. @@ -1080,7 +1080,7 @@ definition({options}) *vim.lsp.buf.definition()* • reuse_win: (boolean) Jump to existing window if buffer is already open. • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| document_highlight() *vim.lsp.buf.document_highlight()* Send request to the server to resolve document highlights for the current @@ -1102,7 +1102,7 @@ document_symbol({options}) *vim.lsp.buf.document_symbol()* Parameters: ~ {options} (table|nil) additional options • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| execute_command({command_params}) *vim.lsp.buf.execute_command()* Executes an LSP server command. @@ -1211,7 +1211,7 @@ implementation({options}) *vim.lsp.buf.implementation()* Parameters: ~ {options} (table|nil) additional options • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| incoming_calls() *vim.lsp.buf.incoming_calls()* Lists all the call sites of the symbol under the cursor in the |quickfix| @@ -1260,7 +1260,7 @@ references({context}, {options}) *vim.lsp.buf.references()* {context} (table) Context for the request {options} (table|nil) additional options • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| See also: ~ https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references @@ -1302,7 +1302,7 @@ type_definition({options}) *vim.lsp.buf.type_definition()* • reuse_win: (boolean) Jump to existing window if buffer is already open. • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| workspace_symbol({query}, {options}) *vim.lsp.buf.workspace_symbol()* Lists all symbols in the current workspace in the quickfix window. @@ -1315,7 +1315,7 @@ workspace_symbol({query}, {options}) *vim.lsp.buf.workspace_symbol()* {query} (string, optional) {options} (table|nil) additional options • on_list: (function) handler for list results. See - |on-list-handler| + |lsp-on-list-handler| ============================================================================== -- cgit From 341ef46d008d765640e65404f8dc7760175d4c7d Mon Sep 17 00:00:00 2001 From: Mathias Fußenegger Date: Thu, 18 Aug 2022 10:57:17 +0200 Subject: docs(lsp): remove lsp.buf_request from docs (#19738) This starts a soft phase-out of `buf_request`. `buf_request` is quite error prone: - Positional `params` depend on the client because of the `offset_encoding`. Currently if there is one client using UTF-8 offset encoding and another using UTF-16, the positions in the request are wrong for one of the clients. To solve this the params would need to be created per client instead of once for all of them. - `handler` is called *per* client but many users of it assume it is only called once. This can lead to a "select n + 1" kind of problem, where the handler makes another call to `buf_request`, multiplying the amount of requests. (There are in fact still some places where this happens in core) Or it leads to erratic behavior if called multiple times (E.g. the quicklist list flickering & being overwritten) (See hover or references implementation) `buf_request_all` returns an aggregate of the responses which is more sensible as it avoids this problem. For off-spec extensions it also has the problem that it sends requests to clients which cannot handle a given request. Given that `buf_request` is in use by a lot of plugins this starts a soft-phase out. Planned Steps: - Remove from docs - Provide an alternative, either `buf_request_all`, maybe with extensions (params being a function), or an entirely new method. - Mark as deprecated in 0.9 - Remove in 0.10 To note: - `buf_request_all` currently isn't ideal either because it suffers from the `params` problem as well. - This implies that the `vim.lsp.with` pattern will die, because the global handlers as they are don't fit a multi-client model, as most of the time an aggregate is needed. --- runtime/doc/lsp.txt | 18 ------------------ 1 file changed, 18 deletions(-) (limited to 'runtime/doc/lsp.txt') diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt index 94aa42e500..7fc0daa0ca 100644 --- a/runtime/doc/lsp.txt +++ b/runtime/doc/lsp.txt @@ -568,24 +568,6 @@ buf_notify({bufnr}, {method}, {params}) *vim.lsp.buf_notify()* Return: ~ true if any client returns true; false otherwise - *vim.lsp.buf_request()* -buf_request({bufnr}, {method}, {params}, {handler}) - Sends an async request for all active clients attached to the buffer. - - Parameters: ~ - {bufnr} (number) Buffer handle, or 0 for current. - {method} (string) LSP method name - {params} (optional, table) Parameters to send to the server - {handler} (optional, function) See |lsp-handler| If nil, follows - resolution strategy defined in |lsp-handler-configuration| - - Return: ~ - 2-tuple: - • Map of client-id:request-id pairs for all successful requests. - • Function which can be used to cancel all the requests. You could - instead iterate all clients and call their `cancel_request()` - methods. - *vim.lsp.buf_request_all()* buf_request_all({bufnr}, {method}, {params}, {callback}) Sends an async request for all active clients attached to the buffer. -- cgit