1017 lines
44 KiB
Plaintext
1017 lines
44 KiB
Plaintext
*lsp.txt* LSP
|
||
|
||
|
||
NVIM REFERENCE MANUAL
|
||
|
||
|
||
LSP client/framework *lsp*
|
||
|
||
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/
|
||
|
||
LSP facilitates features like go-to-definition, find-references, hover,
|
||
completion, rename, format, refactor, etc., using semantic whole-project
|
||
analysis (unlike |ctags|).
|
||
|
||
Type |gO| to see the table of contents.
|
||
|
||
==============================================================================
|
||
QUICKSTART *lsp-quickstart*
|
||
|
||
Nvim provides a LSP client, but the servers are provided by third parties.
|
||
Follow these steps to get LSP features:
|
||
|
||
1. Install the nvim-lsp plugin. It provides common configuration for
|
||
various servers so you can get started quickly.
|
||
https://github.com/neovim/nvim-lsp
|
||
2. Install a language server. Try ":LspInstall <tab>" or use your system
|
||
package manager to install the relevant language server:
|
||
https://microsoft.github.io/language-server-protocol/implementors/servers/
|
||
3. Add `nvim_lsp.xx.setup{…}` to your vimrc, where "xx" is the name of the
|
||
relevant config. See the nvim-lsp README for details.
|
||
|
||
To check LSP clients attached to the current buffer: >
|
||
|
||
:lua print(vim.inspect(vim.lsp.buf_get_clients()))
|
||
<
|
||
*lsp-config*
|
||
Inline diagnostics are enabled automatically, e.g. syntax errors will be
|
||
annotated in the buffer. But you probably want to use other features like
|
||
go-to-definition, hover, etc. Example config: >
|
||
|
||
nnoremap <silent> gd <cmd>lua vim.lsp.buf.declaration()<CR>
|
||
nnoremap <silent> <c-]> <cmd>lua vim.lsp.buf.definition()<CR>
|
||
nnoremap <silent> K <cmd>lua vim.lsp.buf.hover()<CR>
|
||
nnoremap <silent> gD <cmd>lua vim.lsp.buf.implementation()<CR>
|
||
nnoremap <silent> <c-k> <cmd>lua vim.lsp.buf.signature_help()<CR>
|
||
nnoremap <silent> 1gD <cmd>lua vim.lsp.buf.type_definition()<CR>
|
||
nnoremap <silent> gr <cmd>lua vim.lsp.buf.references()<CR>
|
||
|
||
Nvim provides the |vim.lsp.omnifunc| 'omnifunc' handler which allows
|
||
|i_CTRL-X_CTRL-O| to consume LSP completion. Example config (note the use of
|
||
|v:lua| to call Lua from Vimscript): >
|
||
|
||
" Use LSP omni-completion in Python files.
|
||
autocmd Filetype python setlocal omnifunc=v:lua.vim.lsp.omnifunc
|
||
|
||
|
||
================================================================================
|
||
FAQ *lsp-faq*
|
||
|
||
- Q: How to force-reload LSP?
|
||
A: Stop all clients, then reload the buffer. >
|
||
|
||
:lua vim.lsp.stop_all_clients()
|
||
:edit
|
||
|
||
- Q: Why isn't completion working?
|
||
A: In the buffer where you want to use LSP, check that 'omnifunc' is set to
|
||
"v:lua.vim.lsp.omnifunc": >
|
||
|
||
:verbose set omnifunc?
|
||
|
||
< Some other plugin may be overriding the option. To avoid that, you could
|
||
set the option in an |after-directory| ftplugin, e.g.
|
||
"after/ftplugin/python.vim".
|
||
|
||
================================================================================
|
||
LSP HIGHLIGHT *lsp-highlight*
|
||
|
||
When LSP is activated these highlight groups are defined:
|
||
|
||
LspDiagnosticsError
|
||
LspDiagnosticsHint
|
||
LspDiagnosticsInformation
|
||
LspDiagnosticsUnderline
|
||
LspDiagnosticsUnderlineError
|
||
LspDiagnosticsUnderlineHint
|
||
LspDiagnosticsUnderlineInformation
|
||
LspDiagnosticsUnderlineWarning
|
||
LspDiagnosticsWarning
|
||
|
||
================================================================================
|
||
LSP API *lsp-api*
|
||
|
||
The `vim.lsp` Lua module is a framework for building LSP plugins.
|
||
|
||
1. Start with |vim.lsp.start_client()| and |vim.lsp.buf_attach_client()|.
|
||
2. Peek at the API: >
|
||
:lua print(vim.inspect(vim.lsp))
|
||
< 3. See |lsp-extension-example| for a full example.
|
||
|
||
LSP core API is described at |lsp-core|. Those are the core functions for
|
||
creating and managing clients.
|
||
|
||
The `vim.lsp.buf_…` functions perform operations for all LSP clients attached
|
||
to the given buffer. |lsp-buf|
|
||
|
||
LSP request/response handlers are implemented as Lua callbacks.
|
||
|lsp-callbacks| The `vim.lsp.callbacks` table defines default callbacks used
|
||
when creating a new client. Keys are LSP method names: >
|
||
|
||
:lua print(vim.inspect(vim.tbl_keys(vim.lsp.callbacks)))
|
||
|
||
These LSP requests/notifications are defined by default:
|
||
|
||
textDocument/publishDiagnostics
|
||
window/logMessage
|
||
window/showMessage
|
||
|
||
You can check these via `vim.tbl_keys(vim.lsp.callbacks)`.
|
||
|
||
These will be used preferentially in `vim.lsp.buf_…` methods for handling
|
||
requests. They will also be used when responding to server requests and
|
||
notifications.
|
||
|
||
Use cases:
|
||
- Users can modify this to customize to their preferences.
|
||
- UI plugins can modify this by assigning to
|
||
`vim.lsp.callbacks[method]` so as to provide more specialized
|
||
handling, allowing you to leverage the UI capabilities available. UIs should
|
||
try to be conscientious of any existing changes the user may have set
|
||
already by checking for existing values.
|
||
|
||
Any callbacks passed directly to `request` methods on a server client will
|
||
have the highest precedence, followed by the `callbacks`.
|
||
|
||
You can override the default handlers,
|
||
- globally: by modifying the `vim.lsp.callbacks` table
|
||
- per-client: by passing the {callbacks} table parameter to
|
||
|vim.lsp.start_client|
|
||
|
||
Each handler has this signature: >
|
||
|
||
function(err, method, params, client_id)
|
||
|
||
Callbacks are functions which are called in a variety of situations by the
|
||
client. Their signature is `function(err, method, params, client_id)` They can
|
||
be set by the {callbacks} parameter for |vim.lsp.start_client| or via the
|
||
|vim.lsp.callbacks|.
|
||
|
||
Handlers are called for:
|
||
- Notifications from the server (`err` is always `nil`).
|
||
- Requests initiated by the server (`err` is always `nil`).
|
||
The 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.
|
||
- Handling requests initiated by the client if the request doesn't explicitly
|
||
specify a callback (such as in |vim.lsp.buf_request|).
|
||
|
||
|
||
VIM.LSP.PROTOCOL *vim.lsp.protocol*
|
||
|
||
Module `vim.lsp.protocol` defines constants dictated by the LSP specification,
|
||
and helper functions for creating protocol-related objects.
|
||
https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.md
|
||
|
||
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"
|
||
|
||
================================================================================
|
||
LSP EXAMPLE *lsp-extension-example*
|
||
|
||
This example is for plugin authors or users who want a lot of control. If you
|
||
are just getting started see |lsp-quickstart|.
|
||
|
||
For more advanced configurations where just filtering by filetype isn't
|
||
sufficient, you can use the `vim.lsp.start_client()` and
|
||
`vim.lsp.buf_attach_client()` commands to easily customize the configuration
|
||
however you please. For example, if you want to do your own filtering, or
|
||
start a new LSP client based on the root directory for if you plan to work
|
||
with multiple projects in a single session. Below is a fully working Lua
|
||
example which can do exactly that.
|
||
|
||
The example will:
|
||
1. Check for each new buffer whether or not we want to start an LSP client.
|
||
2. Try to find a root directory by ascending from the buffer's path.
|
||
3. Create a new LSP for that root directory if one doesn't exist.
|
||
4. Attach the buffer to the client for that root directory.
|
||
|
||
>
|
||
-- Some path manipulation utilities
|
||
local function is_dir(filename)
|
||
local stat = vim.loop.fs_stat(filename)
|
||
return stat and stat.type == 'directory' or false
|
||
end
|
||
|
||
local path_sep = vim.loop.os_uname().sysname == "Windows" and "\\" or "/"
|
||
-- Asumes filepath is a file.
|
||
local function dirname(filepath)
|
||
local is_changed = false
|
||
local result = filepath:gsub(path_sep.."([^"..path_sep.."]+)$", function()
|
||
is_changed = true
|
||
return ""
|
||
end)
|
||
return result, is_changed
|
||
end
|
||
|
||
local function path_join(...)
|
||
return table.concat(vim.tbl_flatten {...}, path_sep)
|
||
end
|
||
|
||
-- Ascend the buffer's path until we find the rootdir.
|
||
-- is_root_path is a function which returns bool
|
||
local function buffer_find_root_dir(bufnr, is_root_path)
|
||
local bufname = vim.api.nvim_buf_get_name(bufnr)
|
||
if vim.fn.filereadable(bufname) == 0 then
|
||
return nil
|
||
end
|
||
local dir = bufname
|
||
-- Just in case our algo is buggy, don't infinite loop.
|
||
for _ = 1, 100 do
|
||
local did_change
|
||
dir, did_change = dirname(dir)
|
||
if is_root_path(dir, bufname) then
|
||
return dir, bufname
|
||
end
|
||
-- If we can't ascend further, then stop looking.
|
||
if not did_change then
|
||
return nil
|
||
end
|
||
end
|
||
end
|
||
|
||
-- A table to store our root_dir to client_id lookup. We want one LSP per
|
||
-- root directory, and this is how we assert that.
|
||
local javascript_lsps = {}
|
||
-- Which filetypes we want to consider.
|
||
local javascript_filetypes = {
|
||
["javascript.jsx"] = true;
|
||
["javascript"] = true;
|
||
["typescript"] = true;
|
||
["typescript.jsx"] = true;
|
||
}
|
||
|
||
-- Create a template configuration for a server to start, minus the root_dir
|
||
-- which we will specify later.
|
||
local javascript_lsp_config = {
|
||
name = "javascript";
|
||
cmd = { path_join(os.getenv("JAVASCRIPT_LANGUAGE_SERVER_DIRECTORY"), "lib", "language-server-stdio.js") };
|
||
}
|
||
|
||
-- This needs to be global so that we can call it from the autocmd.
|
||
function check_start_javascript_lsp()
|
||
local bufnr = vim.api.nvim_get_current_buf()
|
||
-- Filter which files we are considering.
|
||
if not javascript_filetypes[vim.api.nvim_buf_get_option(bufnr, 'filetype')] then
|
||
return
|
||
end
|
||
-- Try to find our root directory. We will define this as a directory which contains
|
||
-- node_modules. Another choice would be to check for `package.json`, or for `.git`.
|
||
local root_dir = buffer_find_root_dir(bufnr, function(dir)
|
||
return is_dir(path_join(dir, 'node_modules'))
|
||
-- return vim.fn.filereadable(path_join(dir, 'package.json')) == 1
|
||
-- return is_dir(path_join(dir, '.git'))
|
||
end)
|
||
-- We couldn't find a root directory, so ignore this file.
|
||
if not root_dir then return end
|
||
|
||
-- Check if we have a client alredy or start and store it.
|
||
local client_id = javascript_lsps[root_dir]
|
||
if not client_id then
|
||
local new_config = vim.tbl_extend("error", javascript_lsp_config, {
|
||
root_dir = root_dir;
|
||
})
|
||
client_id = vim.lsp.start_client(new_config)
|
||
javascript_lsps[root_dir] = client_id
|
||
end
|
||
-- Finally, attach to the buffer to track changes. This will do nothing if we
|
||
-- are already attached.
|
||
vim.lsp.buf_attach_client(bufnr, client_id)
|
||
end
|
||
|
||
vim.api.nvim_command [[autocmd BufReadPost * lua check_start_javascript_lsp()]]
|
||
<
|
||
|
||
|
||
|
||
==============================================================================
|
||
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.
|
||
|
||
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
|
||
|
||
buf_get_clients({bufnr}) *vim.lsp.buf_get_clients()*
|
||
Gets a map of client_id:client pairs for the given buffer,
|
||
where each value is a |vim.lsp.client| object.
|
||
|
||
Parameters: ~
|
||
{bufnr} (optional, number): Buffer handle, or 0 for
|
||
current
|
||
|
||
buf_get_full_text({bufnr}) *vim.lsp.buf_get_full_text()*
|
||
TODO: Documentation
|
||
|
||
buf_is_attached({bufnr}, {client_id}) *vim.lsp.buf_is_attached()*
|
||
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
|
||
|
||
buf_notify({bufnr}, {method}, {params}) *vim.lsp.buf_notify()*
|
||
Sends a notification to all servers attached to the buffer.
|
||
|
||
Parameters: ~
|
||
{bufnr} (optional, number) Buffer handle, or 0 for
|
||
current
|
||
{method} (string) LSP method name
|
||
{params} (string) Parameters to send to the server
|
||
|
||
Return: ~
|
||
nil
|
||
|
||
*vim.lsp.buf_request()*
|
||
buf_request({bufnr}, {method}, {params}, {callback})
|
||
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
|
||
{callback} (optional, functionnil) Handler
|
||
|
||
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_sync()*
|
||
buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})
|
||
Sends a request to a server and waits for the response.
|
||
|
||
Calls |vim.lsp.buf_request()| 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 100) 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=100) 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.
|
||
|
||
cancel_request({id}) *vim.lsp.cancel_request()*
|
||
TODO: Documentation
|
||
|
||
client() *vim.lsp.client*
|
||
LSP client object.
|
||
|
||
• Methods:
|
||
• request(method, params, [callback]) Send a request to the
|
||
server. If callback is not specified, it will use
|
||
{client.callbacks} to try to find a callback. If one is
|
||
not found there, then an error will occur. This is a thin
|
||
wrapper around {client.rpc.request} with some additional
|
||
checking. Returns a boolean to indicate if the
|
||
notification was successful. If it is false, then it will
|
||
always be false (the client has shutdown). If it was
|
||
successful, then it will return the request id as the
|
||
second result. You can use this with `notify("$/cancel", {
|
||
id = request_id })` to cancel the request. This helper is
|
||
made automatically with |vim.lsp.buf_request()| Returns:
|
||
status, [client_id]
|
||
• notify(method, params) This is just {client.rpc.notify}()
|
||
Returns a boolean to indicate if the notification was
|
||
successful. If it is false, then it will always be false
|
||
(the client has shutdown). Returns: status
|
||
• cancel_request(id) This is just
|
||
{client.rpc.notify}("$/cancelRequest", { id = id })
|
||
Returns the same as `notify()` .
|
||
• stop([force]) Stop 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() Returns true if the client is fully stopped.
|
||
|
||
• 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.
|
||
• offset_encoding (string): The encoding used for
|
||
communicating with the server. You can modify this in the
|
||
`on_init` method before text is sent to the server.
|
||
• callbacks (table): The callbacks used by the client as
|
||
described in |lsp-callbacks|.
|
||
• 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.
|
||
• resolved_capabilities (table): Normalized table of
|
||
capabilities that we have detected based on the initialize
|
||
response from the server in `server_capabilities` .
|
||
|
||
client_is_stopped({client_id}) *vim.lsp.client_is_stopped()*
|
||
TODO: Documentation
|
||
|
||
err_message({...}) *vim.lsp.err_message()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.for_each_buffer_client()*
|
||
for_each_buffer_client({bufnr}, {callback})
|
||
TODO: Documentation
|
||
|
||
get_active_clients() *vim.lsp.get_active_clients()*
|
||
Gets all active clients.
|
||
|
||
Return: ~
|
||
Table of |vim.lsp.client| objects
|
||
|
||
get_client_by_id({client_id}) *vim.lsp.get_client_by_id()*
|
||
Gets an active client by id, or nil if the id is invalid or
|
||
the client is not yet initialized.
|
||
|
||
Parameters: ~
|
||
{client_id} client id number
|
||
|
||
Return: ~
|
||
|vim.lsp.client| object, or nil
|
||
|
||
get_log_path() *vim.lsp.get_log_path()*
|
||
TODO: Documentation
|
||
|
||
initialize() *vim.lsp.initialize()*
|
||
TODO: Documentation
|
||
|
||
is_dir({filename}) *vim.lsp.is_dir()*
|
||
TODO: Documentation
|
||
|
||
is_stopped() *vim.lsp.is_stopped()*
|
||
TODO: Documentation
|
||
|
||
next_client_id() *vim.lsp.next_client_id()*
|
||
TODO: Documentation
|
||
|
||
notification({method}, {params}) *vim.lsp.notification()*
|
||
TODO: Documentation
|
||
|
||
notify({...}) *vim.lsp.notify()*
|
||
TODO: Documentation
|
||
|
||
omnifunc({findstart}, {base}) *vim.lsp.omnifunc()*
|
||
Implements 'omnifunc' compatible LSP completion.
|
||
|
||
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()|)
|
||
|
||
See also: ~
|
||
|complete-functions|
|
||
|complete-items|
|
||
|CompleteDone|
|
||
|
||
on_error({code}, {err}) *vim.lsp.on_error()*
|
||
TODO: Documentation
|
||
|
||
on_exit({code}, {signal}) *vim.lsp.on_exit()*
|
||
TODO: Documentation
|
||
|
||
once({fn}) *vim.lsp.once()*
|
||
TODO: Documentation
|
||
|
||
optional_validator({fn}) *vim.lsp.optional_validator()*
|
||
TODO: Documentation
|
||
|
||
request({method}, {params}, {callback}) *vim.lsp.request()*
|
||
TODO: Documentation
|
||
|
||
resolve_bufnr({bufnr}) *vim.lsp.resolve_bufnr()*
|
||
TODO: Documentation
|
||
|
||
resolve_callback({method}) *vim.lsp.resolve_callback()*
|
||
TODO: Documentation
|
||
|
||
server_request({method}, {params}) *vim.lsp.server_request()*
|
||
TODO: Documentation
|
||
|
||
set_log_level({level}) *vim.lsp.set_log_level()*
|
||
Sets the global log level for LSP logging.
|
||
|
||
Levels by name: "trace", "debug", "info", "warn", "error"
|
||
Level numbers begin with "trace" at 0
|
||
|
||
Use `lsp.log_levels` for reverse lookup.
|
||
|
||
Parameters: ~
|
||
{level} [number|string] the case insensitive level name
|
||
or number
|
||
|
||
See also: ~
|
||
|vim.lsp.log_levels|
|
||
|
||
start_client({config}) *vim.lsp.start_client()*
|
||
Starts and initializes a client with the given configuration.
|
||
|
||
Parameters `cmd` and `root_dir` are required.
|
||
|
||
Parameters: ~
|
||
{root_dir} (required, string) Directory where the
|
||
LSP server will base its rootUri on
|
||
initialization.
|
||
{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"; }
|
||
<
|
||
{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.
|
||
{callbacks} Map of language server method names to `function(err, method, params,
|
||
client_id)` handler. Invoked for:
|
||
• Notifications from the server, where
|
||
`err` will always be `nil` .
|
||
• Requests initiated by the server. For
|
||
these you can respond by returning
|
||
two values: `result, err` where err
|
||
must be shaped like a RPC error, i.e.
|
||
`{ code, message, data? }` . Use
|
||
|vim.lsp.rpc_response_error()| to
|
||
help with this.
|
||
• Default callback for client requests
|
||
not explicitly specifying a callback.
|
||
{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.
|
||
{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.client_errors| for
|
||
possible errors. Use
|
||
`vim.lsp.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
|
||
`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.
|
||
{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"
|
||
|
||
Return: ~
|
||
Client id. |vim.lsp.get_client_by_id()| Note: client is
|
||
only available after it has been initialized, which may
|
||
happen after a small delay (or never if there is an
|
||
error). Use `on_init` to do any actions once the client
|
||
has been initialized.
|
||
|
||
stop({force}) *vim.lsp.stop()*
|
||
TODO: Documentation
|
||
|
||
stop_client({client_id}, {force}) *vim.lsp.stop_client()*
|
||
Stops a client(s).
|
||
|
||
You can also use the `stop()` function on a |vim.lsp.client|
|
||
object. To stop all clients:
|
||
>
|
||
|
||
vim.lsp.stop_client(lsp.get_active_clients())
|
||
<
|
||
|
||
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
|
||
|
||
*vim.lsp.text_document_did_open_handler()*
|
||
text_document_did_open_handler({bufnr}, {client})
|
||
TODO: Documentation
|
||
|
||
unsupported_method({method}) *vim.lsp.unsupported_method()*
|
||
TODO: Documentation
|
||
|
||
validate_client_config({config}) *vim.lsp.validate_client_config()*
|
||
TODO: Documentation
|
||
|
||
validate_command({input}) *vim.lsp.validate_command()*
|
||
TODO: Documentation
|
||
|
||
validate_encoding({encoding}) *vim.lsp.validate_encoding()*
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.protocol *lsp-protocol*
|
||
|
||
ifnil({a}, {b}) *vim.lsp.protocol.ifnil()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.protocol.make_client_capabilities()*
|
||
make_client_capabilities()
|
||
Gets a new ClientCapabilities object describing the LSP client
|
||
capabilities.
|
||
|
||
*vim.lsp.protocol.resolve_capabilities()*
|
||
resolve_capabilities({server_capabilities})
|
||
`*` to match one or more characters in a path segment `?` to
|
||
match on one character in a path segment `**` to match any
|
||
number of path segments, including none `{}` to group
|
||
conditions (e.g. `**/*.{ts,js}` matches all TypeScript and
|
||
JavaScript files) `[]` to declare a range of characters to
|
||
match in a path segment (e.g., `example.[0-9]` to match on
|
||
`example.0` , `example.1` , …) `[!...]` to negate a range of
|
||
characters to match in a path segment (e.g., `example.[!0-9]`
|
||
to match on `example.a` , `example.b` , but not `example.0` )
|
||
|
||
*vim.lsp.protocol.transform_schema_comments()*
|
||
transform_schema_comments()
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.protocol.transform_schema_to_table()*
|
||
transform_schema_to_table()
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.buf *lsp-buf*
|
||
|
||
completion({context}) *vim.lsp.buf.completion()*
|
||
TODO: Documentation
|
||
|
||
declaration() *vim.lsp.buf.declaration()*
|
||
TODO: Documentation
|
||
|
||
definition() *vim.lsp.buf.definition()*
|
||
TODO: Documentation
|
||
|
||
formatting({options}) *vim.lsp.buf.formatting()*
|
||
TODO: Documentation
|
||
|
||
hover() *vim.lsp.buf.hover()*
|
||
TODO: Documentation
|
||
|
||
implementation() *vim.lsp.buf.implementation()*
|
||
TODO: Documentation
|
||
|
||
npcall({fn}, {...}) *vim.lsp.buf.npcall()*
|
||
TODO: Documentation
|
||
|
||
ok_or_nil({status}, {...}) *vim.lsp.buf.ok_or_nil()*
|
||
TODO: Documentation
|
||
|
||
peek_definition() *vim.lsp.buf.peek_definition()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.buf.range_formatting()*
|
||
range_formatting({options}, {start_pos}, {end_pos})
|
||
TODO: Documentation
|
||
|
||
references({context}) *vim.lsp.buf.references()*
|
||
TODO: Documentation
|
||
|
||
rename({new_name}) *vim.lsp.buf.rename()*
|
||
TODO: Documentation
|
||
|
||
request({method}, {params}, {callback}) *vim.lsp.buf.request()*
|
||
TODO: Documentation
|
||
|
||
signature_help() *vim.lsp.buf.signature_help()*
|
||
TODO: Documentation
|
||
|
||
type_definition() *vim.lsp.buf.type_definition()*
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.callbacks *lsp-callbacks*
|
||
|
||
err_message({...}) *vim.lsp.callbacks.err_message()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.callbacks.location_callback()*
|
||
location_callback({_}, {method}, {result})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.callbacks.log_message()*
|
||
log_message({_}, {_}, {result}, {client_id})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.callbacks.signature_help_to_preview_contents()*
|
||
signature_help_to_preview_contents({input})
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.log *lsp-log*
|
||
|
||
get_filename() *vim.lsp.log.get_filename()*
|
||
TODO: Documentation
|
||
|
||
path_join({...}) *vim.lsp.log.path_join()*
|
||
TODO: Documentation
|
||
|
||
set_level({level}) *vim.lsp.log.set_level()*
|
||
TODO: Documentation
|
||
|
||
should_log({level}) *vim.lsp.log.should_log()*
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.rpc *lsp-rpc*
|
||
|
||
convert_NIL({v}) *vim.lsp.rpc.convert_NIL()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.create_and_start_client()*
|
||
create_and_start_client({cmd}, {cmd_args}, {handlers},
|
||
{extra_spawn_params})
|
||
TODO: Documentation
|
||
|
||
encode_and_send({payload}) *vim.lsp.rpc.encode_and_send()*
|
||
TODO: Documentation
|
||
|
||
force_env_list({final_env}) *vim.lsp.rpc.force_env_list()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.format_message_with_content_length()*
|
||
format_message_with_content_length({encoded_message})
|
||
TODO: Documentation
|
||
|
||
format_rpc_error({err}) *vim.lsp.rpc.format_rpc_error()*
|
||
TODO: Documentation
|
||
|
||
handle_body({body}) *vim.lsp.rpc.handle_body()*
|
||
TODO: Documentation
|
||
|
||
is_dir({filename}) *vim.lsp.rpc.is_dir()*
|
||
TODO: Documentation
|
||
|
||
json_decode({data}) *vim.lsp.rpc.json_decode()*
|
||
TODO: Documentation
|
||
|
||
json_encode({data}) *vim.lsp.rpc.json_encode()*
|
||
TODO: Documentation
|
||
|
||
notification({method}, {params}) *vim.lsp.rpc.notification()*
|
||
TODO: Documentation
|
||
|
||
on_error({errkind}, {...}) *vim.lsp.rpc.on_error()*
|
||
TODO: Documentation
|
||
|
||
on_exit({code}, {signal}) *vim.lsp.rpc.on_exit()*
|
||
TODO: Documentation
|
||
|
||
onexit({code}, {signal}) *vim.lsp.rpc.onexit()*
|
||
TODO: Documentation
|
||
|
||
parse_headers({header}) *vim.lsp.rpc.parse_headers()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.pcall_handler()*
|
||
pcall_handler({errkind}, {status}, {head}, {...})
|
||
TODO: Documentation
|
||
|
||
request_parser_loop() *vim.lsp.rpc.request_parser_loop()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.rpc_response_error()*
|
||
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
|
||
|
||
send_notification({method}, {params}) *vim.lsp.rpc.send_notification()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.send_request()*
|
||
send_request({method}, {params}, {callback})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.rpc.send_response()*
|
||
send_response({request_id}, {err}, {result})
|
||
TODO: Documentation
|
||
|
||
server_request({method}, {params}) *vim.lsp.rpc.server_request()*
|
||
TODO: Documentation
|
||
|
||
try_call({errkind}, {fn}, {...}) *vim.lsp.rpc.try_call()*
|
||
TODO: Documentation
|
||
|
||
|
||
==============================================================================
|
||
Lua module: vim.lsp.util *lsp-util*
|
||
|
||
*vim.lsp.util.apply_text_document_edit()*
|
||
apply_text_document_edit({text_document_edit})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.apply_text_edits()*
|
||
apply_text_edits({text_edits}, {bufnr})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.apply_workspace_edit()*
|
||
apply_workspace_edit({workspace_edit})
|
||
TODO: Documentation
|
||
|
||
buf_clear_diagnostics({bufnr}) *vim.lsp.util.buf_clear_diagnostics()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.buf_diagnostics_save_positions()*
|
||
buf_diagnostics_save_positions({bufnr}, {diagnostics})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.buf_diagnostics_underline()*
|
||
buf_diagnostics_underline({bufnr}, {diagnostics})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.buf_diagnostics_virtual_text()*
|
||
buf_diagnostics_virtual_text({bufnr}, {diagnostics})
|
||
TODO: Documentation
|
||
|
||
character_offset({buf}, {row}, {col}) *vim.lsp.util.character_offset()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.close_preview_autocmd()*
|
||
close_preview_autocmd({events}, {winnr})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.convert_input_to_markdown_lines()*
|
||
convert_input_to_markdown_lines({input}, {contents})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.extract_completion_items()*
|
||
extract_completion_items({result})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.fancy_floating_markdown()*
|
||
fancy_floating_markdown({contents}, {opts})
|
||
TODO: Documentation
|
||
|
||
find_window_by_var({name}, {value}) *vim.lsp.util.find_window_by_var()*
|
||
TODO: Documentation
|
||
|
||
focusable_float({unique_name}, {fn}) *vim.lsp.util.focusable_float()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.focusable_preview()*
|
||
focusable_preview({unique_name}, {fn})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.get_current_line_to_cursor()*
|
||
get_current_line_to_cursor()
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.get_severity_highlight_name()*
|
||
get_severity_highlight_name({severity})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.highlight_range()*
|
||
highlight_range({bufnr}, {ns}, {hiname}, {start}, {finish})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.highlight_region()*
|
||
highlight_region({ft}, {start}, {finish})
|
||
TODO: Documentation
|
||
|
||
jump_to_location({location}) *vim.lsp.util.jump_to_location()*
|
||
TODO: Documentation
|
||
|
||
locations_to_items({locations}) *vim.lsp.util.locations_to_items()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.make_floating_popup_options()*
|
||
make_floating_popup_options({width}, {height}, {opts})
|
||
TODO: Documentation
|
||
|
||
make_position_params() *vim.lsp.util.make_position_params()*
|
||
TODO: Documentation
|
||
|
||
npcall({fn}, {...}) *vim.lsp.util.npcall()*
|
||
TODO: Documentation
|
||
|
||
ok_or_nil({status}, {...}) *vim.lsp.util.ok_or_nil()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.open_floating_peek_preview()*
|
||
open_floating_peek_preview({bufnr}, {start}, {finish}, {opts})
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.open_floating_preview()*
|
||
open_floating_preview({contents}, {filetype}, {opts})
|
||
TODO: Documentation
|
||
|
||
set_lines({lines}, {A}, {B}, {new_lines}) *vim.lsp.util.set_lines()*
|
||
TODO: Documentation
|
||
|
||
set_loclist({locations}) *vim.lsp.util.set_loclist()*
|
||
TODO: Documentation
|
||
|
||
set_qflist({locations}) *vim.lsp.util.set_qflist()*
|
||
TODO: Documentation
|
||
|
||
show_line_diagnostics() *vim.lsp.util.show_line_diagnostics()*
|
||
TODO: Documentation
|
||
|
||
sort_by_key({fn}) *vim.lsp.util.sort_by_key()*
|
||
TODO: Documentation
|
||
|
||
split_lines({value}) *vim.lsp.util.split_lines()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.text_document_completion_list_to_complete_items()*
|
||
text_document_completion_list_to_complete_items({result})
|
||
TODO: Documentation
|
||
|
||
trim_empty_lines({lines}) *vim.lsp.util.trim_empty_lines()*
|
||
TODO: Documentation
|
||
|
||
*vim.lsp.util.try_trim_markdown_code_blocks()*
|
||
try_trim_markdown_code_blocks({lines})
|
||
TODO: Documentation
|
||
|
||
validate_lsp_position({pos}) *vim.lsp.util.validate_lsp_position()*
|
||
TODO: Documentation
|
||
|
||
vim:tw=78:ts=8:ft=help:norl:
|