Nvim :help
pages, generated
from source
using the tree-sitter-vimdoc parser.
LSP
vim.lsp
for building
enhanced LSP tools.
-- Create an event handler for the FileType autocommand
vim.api.nvim_create_autocmd('FileType', {
-- This handler will fire when the buffer's 'filetype' is "python"
pattern = 'python',
callback = function(args)
vim.lsp.start({
name = 'my-server-name',
cmd = {'name-of-language-server-executable', '--option', 'arg1', 'arg2'},
-- Set the "root directory" to the parent directory of the file in the
-- current buffer (`args.buf`) that contains either a "setup.py" or a
-- "pyproject.toml" file. Files that share a root directory will reuse
-- the connection to the same LSP server.
root_dir = vim.fs.root(args.buf, {'setup.py', 'pyproject.toml'}),
})
end,
})
:checkhealth lsp
4. (Optional) Configure keymaps and autocommands to use LSP features. lsp-config
lsp-defaults
When the Nvim LSP client starts it enables diagnostics vim.diagnostic (see
vim.diagnostic.config() to customize). It also sets various default options,
listed below, if (1) the language server supports the functionality and (2)
the options are empty or were set by the builtin runtime (ftplugin) files. The
options are not restored when the LSP client is stopped or detached.
K
exists.
grr
gra
grn
i_CTRL-S
Some keymaps are created unconditionally when Nvim starts:
CTRL-S
is mapped in Insert mode to vim.lsp.buf.signature_help()
lsp-defaults-disable
To override or delete any of the above defaults, set or unset the options on
LspAttach:vim.api.nvim_create_autocmd('LspAttach', {
callback = function(args)
vim.bo[args.buf].formatexpr = nil
vim.bo[args.buf].omnifunc = nil
vim.keymap.del('n', 'K', { buffer = args.buf })
end,
})
lsp-config
To use other LSP features, set keymaps and other buffer options on
LspAttach. Not all language servers provide the same capabilities. Use
capability checks to ensure you only use features supported by the language
server. Example:vim.api.nvim_create_autocmd('LspAttach', {
callback = function(args)
local client = vim.lsp.get_client_by_id(args.data.client_id)
if client.supports_method('textDocument/implementation') then
-- Create a keymap for vim.lsp.buf.implementation
end
if client.supports_method('textDocument/completion') then
-- Enable auto-completion
vim.lsp.completion.enable(true, client.id, args.buf, {autotrigger = true})
end
if client.supports_method('textDocument/formatting') then
-- Format the current buffer on save
vim.api.nvim_create_autocmd('BufWritePre', {
buffer = args.buf,
callback = function()
vim.lsp.buf.format({bufnr = args.buf, id = client.id})
end,
})
end,
})
:lua =vim.lsp.get_clients()[1].server_capabilities
Full list of features provided by default can be found in lsp-buf.
:lua vim.lsp.stop_client(vim.lsp.get_clients())
:edit
:verbose set omnifunc?
async
parameter and set the value to
false. E.g. code formatting:" Auto-format *.rs (rust) files prior to saving them
" (async = false is the default for format)
autocmd BufWritePre *.rs lua vim.lsp.buf.format({ async = false })
lsp-vs-treesitter
vim.lsp.buf_…
functions perform operations for all LSP clients attached
to the given buffer. lsp-buf
lsp-method
:lua vim.print(vim.tbl_keys(vim.lsp.handlers))
lsp-handler
LSP handlers are functions that handle lsp-responses to requests made by Nvim
to the server. (Notifications, as opposed to requests, are fire-and-forget:
there is no response, so they can't be handled. lsp-notification)
function(err, result, ctx, config)
{err}
(table|nil
) Error info dict, or nil
if the request
completed.
{ctx}
(table
) Table of calling state associated with the
handler, with these keys:
{bufnr}
(Buffer
) Buffer handle.
{params}
(table|nil
) Request parameters table.
{version}
(number
) Document version at time of
request. Handlers can compare this to the
current document version to check if the
response is "stale". See also b:changedtick.
{config}
(table
) Handler-defined configuration table, which allows
users to customize handler behavior.
For an example, see:
vim.lsp.diagnostic.on_publish_diagnostics()
To configure a particular lsp-handler, see:
lsp-handler-configuration
result, err
where err
is shaped like an RPC error:{ code, message, data? }
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, {
-- Enable signs
signs = true,
}
)
{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,
}
),
},
}
{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
}
),
}
}
local on_references = vim.lsp.handlers["textDocument/references"]
vim.lsp.handlers["textDocument/references"] = vim.lsp.with(
on_references, {
-- Use location list instead of quickfix list
loclist = true,
}
)
lsp-handler-resolution
Handlers can be set by:
vim.lsp.handlers
vim.lsp.handlers is a global table that contains the default mapping of
lsp-method names to lsp-handlers. To override the handler for the
"textDocument/definition"
method:vim.lsp.handlers["textDocument/definition"] = my_custom_default_definition
{handlers}
parameter of vim.lsp.start(). This sets the default
lsp-handler for the server being started. Example:vim.lsp.start {
..., -- Other configuration omitted.
handlers = {
["textDocument/definition"] = my_custom_server_definition
},
}
{handler}
parameter of vim.lsp.buf_request_all(). This sets
the lsp-handler ONLY for the given request(s). Example:vim.lsp.buf_request_all(
0,
"textDocument/definition",
my_request_params,
my_handler
)
vim.lsp.log_levels
Log levels are defined in vim.log.levels
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
vim.lsp.protocol.ErrorCodes
allows reverse lookup by number or
name:vim.lsp.protocol.TextDocumentSyncKind.Full == 1
vim.lsp.protocol.TextDocumentSyncKind[1] == "Full"
lsp-response
LSP response shape:
https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
lsp-notification
LSP notification shape:
https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
hl-LspReferenceText
LspReferenceText used for highlighting "text" references
hl-LspReferenceRead
LspReferenceRead used for highlighting "read" references
hl-LspReferenceWrite
LspReferenceWrite used for highlighting "write" references
hl-LspInlayHint
LspInlayHint used for highlighting inlay hints
hl-LspCodeLens
LspCodeLens
Used to color the virtual text of the codelens. See
nvim_buf_set_extmark().
hl-LspCodeLensSeparator
Used to color the separator between two or more code lenses.
hl-LspSignatureActiveParameter
LspSignatureActiveParameter
Used to highlight the active parameter in the signature help. See
vim.lsp.handlers.signature_help().
type
such as "function" or "variable", and 0 or more
modifier
s such as "readonly" or "deprecated." The standard types and
modifiers are described here:
https://microsoft.github.io/language-server-protocol/specification/#textDocument_semanticTokens
LSP servers may also use off-spec types and modifiers.
@lsp.type.<type>.<ft>
for the type
@lsp.mod.<mod>.<ft>
for each modifier
@lsp.typemod.<type>.<mod>.<ft>
for each modifier
Use :Inspect to view the highlights for a specific token. Use :hi or
nvim_set_hl() to change the appearance of semantic highlights:hi @lsp.type.function guifg=Yellow " function names are yellow
hi @lsp.type.variable.lua guifg=Green " variables in lua are green
hi @lsp.mod.deprecated gui=strikethrough " deprecated is crossed out
hi @lsp.typemod.function.async guifg=Blue " async functions are blue
.semantic_tokens
is the priority of the
@lsp.type.*
highlights. The @lsp.mod.*
and @lsp.typemod.*
highlights
have priorities one and two higher, respectively.
-- Hide semantic highlights for functions
vim.api.nvim_set_hl(0, '@lsp.type.function', {})
-- Hide all semantic highlights
for _, group in ipairs(vim.fn.getcompletion("@lsp", "highlight")) do
vim.api.nvim_set_hl(0, group, {})
end
LspAttach
After an LSP client attaches to a buffer. The autocmd-pattern is the
name of the buffer. When used from Lua, the client ID is passed to the
callback in the "data" table. Example:vim.api.nvim_create_autocmd("LspAttach", {
callback = function(args)
local bufnr = args.buf
local client = vim.lsp.get_client_by_id(args.data.client_id)
if client.supports_method("textDocument/completion") then
vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
end
if client.supports_method("textDocument/definition") then
vim.bo[bufnr].tagfunc = "v:lua.vim.lsp.tagfunc"
end
end,
})
LspDetach
Just before an LSP client detaches from a buffer. The autocmd-pattern
is the name of the buffer. When used from Lua, the client ID is passed
to the callback in the "data" table. Example:vim.api.nvim_create_autocmd("LspDetach", {
callback = function(args)
local client = vim.lsp.get_client_by_id(args.data.client_id)
-- Do something with the client
vim.cmd("setlocal tagfunc< omnifunc<")
end,
})
LspNotify
This event is triggered after each successful notification sent to an
LSP server.
vim.api.nvim_create_autocmd('LspNotify', {
callback = function(args)
local bufnr = args.buf
local client_id = args.data.client_id
local method = args.data.method
local params = args.data.params
-- do something with the notification
if method == 'textDocument/...' then
update_buffer(bufnr)
end
end,
})
LspProgress
Upon receipt of a progress notification from the server. Notifications can
be polled from a progress
ring buffer of a vim.lsp.Client or use
vim.lsp.status() to get an aggregate message.
pattern
is set to kind
(one of begin
, report
or end
).
data
table with client_id
and
params
properties. params
will contain the request params sent by the
server (see lsp.ProgressParams
).
autocmd LspProgress * redrawstatus
LspRequest
For each request sent to an LSP server, this event is triggered for
every change to the request's status. The status can be one of
pending
, complete
, or cancel
and is sent as the {type}
on the
"data" table passed to the callback function.
{type}
== pending
) and
when the LSP server responds ({type}
== complete
). If a cancellation
is requested using client.cancel_request(request_id)
, then this event
will trigger with {type}
== cancel
.
{requests}
in vim.lsp.Client for details on the
{request}
value. If the request type is complete
, the request will be
deleted from the client's pending requests table immediately after
calling the event's callbacks. Example:vim.api.nvim_create_autocmd('LspRequest', {
callback = function(args)
local bufnr = args.buf
local client_id = args.data.client_id
local request_id = args.data.request_id
local request = args.data.request
if request.type == 'pending' then
-- do something with pending requests
track_pending(client_id, bufnr, request_id, request)
elseif request.type == 'cancel' then
-- do something with pending cancel requests
track_canceling(client_id, bufnr, request_id, request)
elseif request.type == 'complete' then
-- do something with finished requests. this pending
-- request entry is about to be removed since it is complete
track_finish(client_id, bufnr, request_id, request)
end
end,
})
LspTokenUpdate
When a visible semantic token is sent or updated by the LSP server, or
when an existing token becomes visible for the first time. The
autocmd-pattern is the name of the buffer. When used from Lua, the
token and client ID are passed to the callback in the "data" table. The
token fields are documented in vim.lsp.semantic_tokens.get_at_pos().
Example:
vim.api.nvim_create_autocmd('LspTokenUpdate', {
callback = function(args)
local token = args.data.token
if token.type == 'variable' and not token.modifiers.readonly then
vim.lsp.semantic_tokens.highlight_token(
token, args.buf, args.data.client_id, 'MyMutableVariableHighlight'
)
end
end,
})
{bufnr}
, {client_id}
) vim.lsp.buf_attach_client()
Implements the textDocument/did…
notifications required to track a
buffer for any language server.
{bufnr}
(integer
) Buffer handle, or 0 for current
{client_id}
(integer
) Client id
boolean
) success true
if client was attached successfully;
false
otherwise
{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.
{bufnr}
(integer
) Buffer handle, or 0 for current
{client_id}
(integer
) Client id
{bufnr}
, {client_id}
) vim.lsp.buf_is_attached()
Checks if a buffer is attached for a particular client.
{bufnr}
(integer
) Buffer handle, or 0 for current
{client_id}
(integer
) the client id
{bufnr}
(integer?
) The number of the buffer
{method}
(string
) Name of the request method
{params}
(any
) Arguments to send to the server
boolean
) success true if any client returns true; false otherwise
vim.lsp.buf_request_all()
buf_request_all({bufnr}
, {method}
, {params}
, {handler}
)
Sends an async request for all active clients attached to the buffer and
executes the handler
callback with the combined result.
{bufnr}
(integer
) Buffer handle, or 0 for current.
{method}
(string
) LSP method name
{params}
(table?
) Parameters to send to the server
{handler}
(function
) Handler called after all requests are
completed. Server results are passed as a
client_id:result
map.
function
) cancel Function that cancels all requests.
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.
{timeout_ms}
.
{bufnr}
(integer
) Buffer handle, or 0 for current.
{method}
(string
) LSP method name
{params}
(table?
) Parameters to send to the server
{timeout_ms}
(integer?
, default: 1000
) Maximum time in
milliseconds to wait for a result.
table<integer, {error: lsp.ResponseError?, result: any}>?
) result
Map of client_id:request_result.
(string?
) err On timeout, cancel, or error, err
is a string
describing the failure reason, and result
is nil.
{client_id}
) vim.lsp.client_is_stopped()
Checks whether a client is stopped.
{client_id}
(integer
)
boolean
) stopped true if client is stopped, false otherwise.
vim.lsp.commands
Registry for client side commands. This is an extension point for plugins
to handle custom commands which are not part of the core language server
protocol specification.
workspace/executeCommand
.
Command
: Command title:
String command: String arguments?: any[]
ctx
of lsp-handler
{opts}
) vim.lsp.formatexpr()
Provides an interface between the built-in client and a formatexpr
function.
setlocal formatexpr=v:lua.vim.lsp.formatexpr()
or (more typically) in
on_attach
via
vim.bo[bufnr].formatexpr = 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})'
.
{opts}
(table?
) A table with the following fields:
{timeout_ms}
(integer
, default: 500ms) The timeout period
for the formatting request..
vim.lsp.get_buffers_by_client_id()
get_buffers_by_client_id({client_id}
)
Returns list of buffers attached to client_id.
{client_id}
(integer
) client id
integer[]
) buffers list of buffer ids
{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.
{client_id}
(integer
) client id
vim.lsp.Client?
) client rpc object
{filter}
) vim.lsp.get_clients()
Get active clients.
{filter}
(table?
) Key-value pairs used to filter the returned
clients.
{id}
(integer
) Only return clients with the given id
{bufnr}
(integer
) Only return clients attached to this
buffer
{name}
(string
) Only return clients with the given name
{method}
(string
) Only return clients supporting the
given method
vim.lsp.get_log_path()
Gets the path of the logfile used by the LSP client.
string
) path to log file
{findstart}
(integer
) 0 or 1, decides behavior
{base}
(integer
) findstart=0, text to match against
integer|table
) Decided by {findstart}
:
{level}
) vim.lsp.set_log_level()
Sets the global log level for LSP logging.
lsp.log_levels
for reverse lookup.
{level}
(integer|string
) the case insensitive level name or number
{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.
vim.lsp.start({
name = 'my-server-name',
cmd = {'name-of-language-server-executable'},
root_dir = vim.fs.root(0, {'pyproject.toml', 'setup.py'}),
})
name
arbitrary name for the LSP client. Should be unique per language
server.
cmd
command string[] or function, described at
vim.lsp.start_client().
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.root() 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
list of { uri:string, name: string }
tables
specifying the project root folders used by the language server. If
nil
the property is derived from root_dir
for convenience.
ftplugin/<filetype_name>.lua
(See ftplugin-name)
{opts}
(table?
) Optional keyword arguments
{reuse_client}
(fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig): 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.
{bufnr}
(integer
) Buffer handle to attach to if
starting or re-using a client (0 for current).
{silent}
(boolean
) Suppress error reporting if the LSP
server fails to start (default false).
integer?
) client_id
{config}
) vim.lsp.start_client()
Starts and initializes a client with the given configuration.
integer?
) 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.
(string?
) Error message, if any
vim.lsp.status()
Consumes the latest progress messages from all clients and formats them as
a string. Empty if there are no clients or if no new messages
string
)
stop()
function on a vim.lsp.Client object. To
stop all clients:vim.lsp.stop_client(vim.lsp.get_clients())
{client_id}
(integer|integer[]|vim.lsp.Client[]
) id, list of id's,
or list of vim.lsp.Client objects
{force}
(boolean?
) shutdown forcefully
{pattern}
, {flags}
) vim.lsp.tagfunc()
Provides an interface between the built-in client and 'tagfunc'.
{pattern}
(string
) Pattern used to find a workspace symbol
table[]
) tags A list of matching tags
{handler}
, {override_config}
) vim.lsp.with()
Function to manage overriding defaults for LSP handlers.
{override_config}
(table
) Table containing the keys to override
behavior of the {handler}
{id}
(integer
) 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}
(vim.lsp.rpc.PublicClient
) 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.
{requests}
(table<integer,{ type: string, bufnr: integer, method: string}>
)
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. It will be "complete"
ephemerally while executing LspRequest
autocmds when replies are received from the
server.
{config}
(vim.lsp.ClientConfig
) copy of the table
that was passed by the user to
vim.lsp.start_client(). See
vim.lsp.ClientConfig.
{server_capabilities}
(lsp.ServerCapabilities?
) Response from the
server sent on initialize
describing the
server's capabilities.
{progress}
(vim.lsp.Client.Progress
) A ring buffer
(vim.ringbuf()) containing progress messages
sent by the server. See
vim.lsp.Client.Progress.
{initialized}
(true?
)
{workspace_folders}
(lsp.WorkspaceFolder[]?
) The workspace
folders configured in the client when the
server starts. This property is only available
if the client supports workspace folders. It
can be null
if the client supports workspace
folders but none are configured.
{root_dir}
(string?
)
{attached_buffers}
(table<integer,true>
)
{commands}
(table<string,fun(command: lsp.Command, ctx: table)>
)
Table of command name to function which is
called if any LSP action (code action, code
lenses, ...) triggers the command. Client
commands take precedence over the global
command registry.
{settings}
(table
) Map with language server specific
settings. These are returned to the language
server if requested via
workspace/configuration
. Keys are
case-sensitive.
{flags}
(table
) A table with flags for the client.
The current (experimental) flags are:
{allow_incremental_sync}
(boolean
,
default: true
) Allow using incremental
sync for buffer edits
{debounce_text_changes}
(integer
, default:
150
) Debounce didChange
notifications to
the server by the given number in
milliseconds. No debounce occurs if nil
.
{exit_timeout}
(integer|false
, 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.
{get_language_id}
(fun(bufnr: integer, filetype: string): string
)
{capabilities}
(lsp.ClientCapabilities
) The capabilities
provided by the client (editor or tool)
{dynamic_capabilities}
(lsp.DynamicCapabilities
)
{request}
(fun(method: string, params: table?, handler: lsp.Handler?, bufnr: integer?): boolean, integer?
)
Sends a request to the server. This is a thin
wrapper around {client.rpc.request}
with some
additional checking. If {handler}
is not
specified and if there's no respective global
handler, 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}
(fun(method: string, params: table?, timeout_ms: integer?, bufnr: integer): {err: lsp.ResponseError?, result:any}?, string?
)
err # a dictionary, where
{notify}
(fun(method: string, params: table?): boolean
)
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}
(fun(id: integer): boolean
) Cancels a
request with a given request id. Returns: same
as notify()
.
{stop}
(fun(force?: boolean)
) 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.
{on_attach}
(fun(bufnr: integer)
) Runs the on_attach
function from the client's config if it was
defined. Useful for buffer-local setup.
{supports_method}
(fun(method: string, opts?: {bufnr: integer?}): boolean
)
Checks if a client supports a given method.
Always returns true for unknown off-spec
methods. {opts}
is a optional
{bufnr?: integer}
table. Some language
server capabilities can be file specific.
{is_stopped}
(fun(): boolean
) Checks whether a client is
stopped. Returns: true if the client is fully
stopped.
vim.lsp.Client.Progress
Extends: vim.Ringbuf
{pending}
(table<lsp.ProgressToken,lsp.LSPAny>
)
{cmd}
(string[]|fun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient
)
command string[] that launches the language
server (treated as in jobstart(), must be
absolute or on $PATH
, shell constructs like
"~" are not expanded), or function that creates
an RPC client. Function receives a dispatchers
table and returns a table with member functions
request
, notify
, is_closing
and
terminate
. See vim.lsp.rpc.request(),
vim.lsp.rpc.notify(). For TCP there is a
builtin RPC client factory:
vim.lsp.rpc.connect()
{cmd_cwd}
(string
, default: cwd) Directory to launch the
cmd
process. Not related to root_dir
.
{cmd_env}
(table
) Environment flags to pass to the LSP
on spawn. Must be specified using a table.
Non-string values are coerced to string.
Example:{ 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}
(lsp.WorkspaceFolder[]
) 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}
(lsp.ClientCapabilities
) 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.
{settings}
(table
) Map with language server specific
settings. See the {settings}
in
vim.lsp.Client.
{commands}
(table<string,fun(command: lsp.Command, ctx: 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}
(table
) 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}
(fun(bufnr: integer, filetype: string): string
)
Language ID as string. Defaults to the filetype.
{offset_encoding}
('utf-8'|'utf-16'|'utf-32'
) The encoding that
the LSP server expects. Client does not verify
this is correct.
{on_error}
(fun(code: integer, err: string)
) Callback
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}
(fun(params: lsp.InitializeParams, config: vim.lsp.ClientConfig)
)
Callback 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}
(elem_or_list<fun(client: vim.lsp.Client, initialize_result: lsp.InitializeResult)>
)
Callback 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}
(elem_or_list<fun(code: integer, signal: integer, client_id: integer)>
)
Callback invoked on client exit.
{on_attach}
(elem_or_list<fun(client: vim.lsp.Client, bufnr: integer)>
)
Callback invoked when client attaches to a
buffer.
{trace}
('off'|'messages'|'verbose'
, default: "off")
Passed directly to the language server in the
initialize request. Invalid/empty values will
{flags}
(table
) A table with flags for the client. The
current (experimental) flags are:
{allow_incremental_sync}
(boolean
, default:
true
) Allow using incremental sync for
buffer edits
{debounce_text_changes}
(integer
, default:
150
) Debounce didChange
notifications to
the server by the given number in
milliseconds. No debounce occurs if nil
.
{exit_timeout}
(integer|false
, 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.
{on_list}
(fun(t: vim.lsp.LocationOpts.OnList)
) list-handler
replacing the default handler. Called for any non-empty
result. This table can be used with setqflist() or
setloclist(). E.g.:local function on_list(options)
vim.fn.setqflist({}, ' ', options)
vim.cmd.cfirst()
end
vim.lsp.buf.definition({ on_list = on_list })
vim.lsp.buf.references(nil, { on_list = on_list })
vim.lsp.buf.definition({ loclist = true })
vim.lsp.buf.references(nil, { loclist = true })
{loclist}
(boolean
)
vim.lsp.LocationOpts
Extends: vim.lsp.ListOpts
{reuse_win}
(boolean
) Jump to existing window if buffer is already
open.
{title}
(string
) Title for the list.
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().
{workspace_folder}
(string?
)
vim.lsp.buf.clear_references()
Removes document highlights from current buffer.
{opts}
) vim.lsp.buf.code_action()
Selects a code action available at the current cursor position.
{opts}
(table?
) A table with the following fields:
{context}
(lsp.CodeActionContext
) Corresponds to
CodeActionContext
of the LSP specification:
{diagnostics}
(table
) LSP Diagnostic[]
. Inferred from
the current position if not provided.
{only}
(table
) List of LSP CodeActionKind
s used to
filter the code actions. Most language servers support
values like refactor
or quickfix
.
{triggerKind}
(integer
) The reason why code actions
were requested.
{filter}
(fun(x: lsp.CodeAction|lsp.Command):boolean
)
Predicate taking an CodeAction
and returning a boolean.
{apply}
(boolean
) When set to true
, and there is just
one remaining action (after filtering), the action is
applied without user query.
{range}
({start: integer[], end: integer[]}
) 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
{context}
) vim.lsp.buf.completion()
Retrieves the completion items at the current cursor position. Can only be
called in Insert mode.
{context}
(table
) (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)
{opts}
) vim.lsp.buf.declaration()
Jumps to the declaration of the symbol under the cursor.
{opts}
) vim.lsp.buf.definition()
Jumps to the definition of the symbol under the cursor.
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.:autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight()
autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
{opts}
) vim.lsp.buf.document_symbol()
Lists all symbols in the current buffer in the quickfix window.
{command_params}
) vim.lsp.buf.execute_command()
Executes an LSP server command.
{command_params}
(lsp.ExecuteCommandParams
)
{opts}
) vim.lsp.buf.format()
Formats a buffer using the attached (and optionally filtered) language
server clients.
{opts}
(table?
) A table with the following fields:
{formatting_options}
(table
) Can be used to specify
FormattingOptions. Some unspecified options will be
automatically derived from the current Nvim options. See
https://microsoft.github.io/language-server-protocol/specification/#formattingOptions
{timeout_ms}
(integer
, default: 1000
) Time in
milliseconds to block for formatting requests. No effect if
async=true.
{bufnr}
(integer
, default: current buffer) Restrict
formatting to the clients attached to the given buffer.
{filter}
(fun(client: vim.lsp.Client): boolean?
)
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
, default: false) If true the method
won't block. Editing the buffer while formatting
asynchronous can lead to unexpected changes.
{id}
(integer
) Restrict formatting to the client with ID
(client.id) matching this field.
{name}
(string
) Restrict formatting to the client with
name (client.name) matching this field.
{range}
({start:[integer,integer],end:[integer, integer]}|{start:[integer,integer],end:[integer,integer]}[]
,
default: current selection in visual mode, nil
in other
modes, formatting the full buffer) Range to format. Table
must contain start
and end
keys with {row,col}
tuples
using (1,0) indexing. Can also be a list of tables that
contain start
and end
keys as described above, in which
case textDocument/rangesFormatting
support is required.
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.
{opts}
) vim.lsp.buf.implementation()
Lists all the implementations for the symbol under the cursor in the
quickfix window.
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().
vim.lsp.buf.list_workspace_folders()
List workspace folders.
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().
{context}
, {opts}
) vim.lsp.buf.references()
Lists all the references to the symbol under the cursor in the quickfix
window.
{context}
(table?
) Context for the request
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().
{workspace_folder}
(string?
)
{new_name}
, {opts}
) vim.lsp.buf.rename()
Renames all references to the symbol under the cursor.
{new_name}
(string?
) If not provided, the user will be prompted for
a new name using vim.ui.input().
{opts}
(table?
) Additional options:
{filter}
(fun(client: vim.lsp.Client): boolean?
)
Predicate used to filter clients. Receives a client as
argument and must return a boolean. Clients matching the
predicate are included.
{name}
(string
) Restrict clients used for rename to
ones where client.name matches this field.
{bufnr}
(integer
) (default: current buffer)
vim.lsp.buf.signature_help()
Displays signature information about the symbol under the cursor in a
floating window.
{opts}
) vim.lsp.buf.type_definition()
Jumps to the definition of the type of the symbol under the cursor.
{kind}
) vim.lsp.buf.typehierarchy()
Lists all the subtypes or supertypes of the symbol under the cursor in the
quickfix window. If the symbol can resolve to multiple items, the user
can pick one using vim.ui.select().
{kind}
("subtypes"|"supertypes"
)
{query}
, {opts}
) vim.lsp.buf.workspace_symbol()
Lists all symbols in the current workspace in the quickfix window.
{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.
{diagnostics}
) vim.lsp.diagnostic.from()
Converts the input vim.Diagnostic
s to LSP diagnostics.
{diagnostics}
(vim.Diagnostic[]
)
lsp.Diagnostic[]
)
vim.lsp.diagnostic.get_namespace()
get_namespace({client_id}
, {is_pull}
)
Get the diagnostic namespace associated with an LSP client
vim.diagnostic for diagnostics
{client_id}
(integer
) The id of the LSP client
{is_pull}
(boolean?
) Whether the namespace is for a pull or push
client. Defaults to push
vim.lsp.diagnostic.on_diagnostic()
on_diagnostic({_}
, {result}
, {ctx}
, {config}
)
lsp-handler for the method "textDocument/diagnostic"
vim.lsp.handlers["textDocument/diagnostic"] = vim.lsp.with(
vim.lsp.diagnostic.on_diagnostic, {
-- 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,
}
)
{result}
(lsp.DocumentDiagnosticReport
)
{ctx}
(lsp.HandlerContext
)
vim.lsp.diagnostic.on_publish_diagnostics()
on_publish_diagnostics({_}
, {result}
, {ctx}
, {config}
)
lsp-handler for the method "textDocument/publishDiagnostics"
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,
}
)
{result}
(lsp.PublishDiagnosticsParams
)
{ctx}
(lsp.HandlerContext
)
{client_id}
(integer?
) filter by client_id. All clients if nil
{bufnr}
(integer?
) filter by buffer. All buffers if nil, 0 for
current buffer
{lenses}
, {bufnr}
, {client_id}
) vim.lsp.codelens.display()
Display the lenses using virtual text
{lenses}
(lsp.CodeLens[]?
) lenses to display
{bufnr}
(integer
)
{client_id}
(integer
)
{bufnr}
) vim.lsp.codelens.get()
Return all lenses for the given buffer
{bufnr}
(integer
) Buffer number. 0 can be used for the current
buffer.
lsp.CodeLens[]
)
{err}
, {result}
, {ctx}
) vim.lsp.codelens.on_codelens()
lsp-handler for the method textDocument/codeLens
{err}
(lsp.ResponseError?
)
{result}
(lsp.CodeLens[]
)
{ctx}
(lsp.HandlerContext
)
{opts}
) vim.lsp.codelens.refresh()
Refresh the lenses.
autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh({ bufnr = 0 })
{opts}
(table?
) Optional fields
{bufnr}
(integer?
) filter by buffer. All buffers if nil, 0
for current buffer
vim.lsp.codelens.run()
Run the code lens in the current line
{lenses}
, {bufnr}
, {client_id}
) vim.lsp.codelens.save()
Store lenses for a specific buffer and client
{lenses}
(lsp.CodeLens[]?
) lenses to store
{bufnr}
(integer
)
{client_id}
(integer
)
{autotrigger}
(boolean
) Whether to trigger completion
automatically. Default: false
{convert}
(fun(item: lsp.CompletionItem): table
) Transforms an
LSP CompletionItem to complete-items.
vim.lsp.completion.enable()
enable({enable}
, {client_id}
, {bufnr}
, {opts}
)
Enables or disables completions from the given language client in the
given buffer.
{enable}
(boolean
) True to enable, false to disable
{client_id}
(integer
) Client ID
{bufnr}
(integer
) Buffer handle, or 0 for the current buffer
vim.lsp.completion.trigger()
Trigger LSP completion in the current buffer.
{enable}
, {filter}
) vim.lsp.inlay_hint.enable()
Enables or disables inlay hints for the {filter}
ed scope.
is_enabled()
:vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())
{enable}
(boolean?
) true/nil to enable, false to disable
{bufnr}
(integer?
) Buffer number, or 0 for current
buffer, or nil for all.
{filter}
) vim.lsp.inlay_hint.get()
Get the list of inlay hints, (optionally) restricted by buffer or range.
local hint = vim.lsp.inlay_hint.get({ bufnr = 0 })[1] -- 0 for current buffer
local client = vim.lsp.get_client_by_id(hint.client_id)
local resp = client.request_sync('inlayHint/resolve', hint.inlay_hint, 100, 0)
local resolved_hint = assert(resp and resp.result, resp.err)
vim.lsp.util.apply_text_edits(resolved_hint.textEdits, 0, client.encoding)
location = resolved_hint.label[1].location
client.request('textDocument/hover', {
textDocument = { uri = location.uri },
position = location.range.start,
})
table[]
) A list of objects with the following fields:
{bufnr}
(integer
)
{client_id}
(integer
)
{inlay_hint}
(lsp.InlayHint
)
{filter}
) vim.lsp.inlay_hint.is_enabled()
Query whether inlay hint is enabled in the {filter}
ed scope
{bufnr}
(integer?
) Buffer number, or 0 for current
buffer, or nil for all.
boolean
)
{bufnr}
) vim.lsp.semantic_tokens.force_refresh()
Force a refresh of all semantic tokens
{bufnr}
(integer?
) filter by buffer. All buffers if nil, current
buffer if 0
vim.lsp.semantic_tokens.get_at_pos()
get_at_pos({bufnr}
, {row}
, {col}
)
Return the semantic token(s) at the given position. If called without
arguments, returns the token under the cursor.
{bufnr}
(integer?
) Buffer number (0 for current buffer, default)
{row}
(integer?
) Position row (default cursor position)
{col}
(integer?
) Position column (default cursor position)
table?
) List of tokens at position. Each token has the following
fields:
vim.lsp.semantic_tokens.highlight_token()
highlight_token({token}
, {bufnr}
, {client_id}
, {hl_group}
, {opts}
)
Highlight a semantic token.
{bufnr}
(integer
) The buffer to highlight, or 0
for current
buffer
{hl_group}
(string
) Highlight group name
{opts}
(table?
) Optional parameters:
{priority}
(integer
, default:
vim.highlight.priorities.semantic_tokens + 3
)
Priority for the applied extmark.
{bufnr}
, {client_id}
, {opts}
) vim.lsp.semantic_tokens.start()
Start the semantic token highlighting engine for the given buffer with the
given client. The client must already be attached to the buffer.
{server_capabilities}
of your client in your LspAttach callback
or your configuration's on_attach
callback:client.server_capabilities.semanticTokensProvider = nil
{bufnr}
(integer
) Buffer number, or 0
for current buffer
{opts}
(table?
) Optional keyword arguments
{bufnr}
, {client_id}
) vim.lsp.semantic_tokens.stop()
Stop the semantic token highlighting engine for the given buffer with the
given client.
start()
, so you should only need this function to manually
disengage the semantic token engine without fully detaching the LSP client
from the buffer.
{bufnr}
(integer
) Buffer number, or 0
for current buffer
{_}
, {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",
-- add the title in hover float window
title = "hover"
}
)
{result}
(lsp.Hover
)
{ctx}
(lsp.HandlerContext
)
{config}
(table
) Configuration table.
vim.lsp.handlers.signature_help()
signature_help({_}
, {result}
, {ctx}
, {config}
)
lsp-handler for the method "textDocument/signatureHelp".
vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
vim.lsp.handlers.signature_help, {
-- Use a sharp border with `FloatBorder` highlights
border = "single"
}
)
{result}
(lsp.SignatureHelp
) Response from the language server
{ctx}
(lsp.HandlerContext
) Client context
{config}
(table
) Configuration table.
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.
{text_document_edit}
(lsp.TextDocumentEdit
)
{index}
(integer?
) Optional index of the edit, if from
a list of edits (or nil, if not from a list)
{offset_encoding}
(string?
)
vim.lsp.util.apply_text_edits()
apply_text_edits({text_edits}
, {bufnr}
, {offset_encoding}
)
Applies a list of text edits to a buffer.
{text_edits}
(lsp.TextEdit[]
)
{bufnr}
(integer
) Buffer id
{offset_encoding}
(string
) utf-8|utf-16|utf-32
vim.lsp.util.apply_workspace_edit()
apply_workspace_edit({workspace_edit}
, {offset_encoding}
)
Applies a WorkspaceEdit
.
{workspace_edit}
(lsp.WorkspaceEdit
)
{offset_encoding}
(string
) utf-8|utf-16|utf-32 (required)
{bufnr}
) vim.lsp.util.buf_clear_references()
Removes document highlights from a buffer.
{bufnr}
(integer?
) 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.
{bufnr}
(integer
) Buffer id
{references}
(lsp.DocumentHighlight[]
) objects to highlight
{offset_encoding}
(string
) One of "utf-8", "utf-16", "utf-32".
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.
{buf}
(integer
) buffer number (0 for current)
{row}
(integer
) 0-indexed line
{col}
(integer
) 0-indexed byte offset in line
{offset_encoding}
(string
) utf-8|utf-16|utf-32 defaults to
offset_encoding
of first client of buf
integer
) 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.
MarkupContent
and its kind is
plaintext
, then the corresponding value is returned without further
modifications.
{input}
(lsp.MarkedString|lsp.MarkedString[]|lsp.MarkupContent
)
{contents}
(string[]?
) List of strings to extend with converted
lines. Defaults to {}.
string[]
) extended with lines of converted markdown.
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.
{signature_help}
(lsp.SignatureHelp
) Response of
textDocument/SignatureHelp
{ft}
(string?
) filetype that will be use as the lang
for the label markdown code block
{triggers}
(table?
) list of trigger characters from the lsp
server. used to better determine parameter offsets
string[]?
) table list of lines of converted markdown.
(number[]?
) table of active hl
{bufnr}
) vim.lsp.util.get_effective_tabstop()
Returns indentation size.
{bufnr}
(integer?
) Buffer handle, defaults to current
integer
) indentation size
vim.lsp.util.jump_to_location()
jump_to_location({location}
, {offset_encoding}
, {reuse_win}
)
Jumps to a location.
{location}
(lsp.Location|lsp.LocationLink
)
{offset_encoding}
(string?
) utf-8|utf-16|utf-32
{reuse_win}
(boolean?
) Jump to existing window if buffer is
already open.
boolean
) 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.
user_data
field of each resulting item will contain the original
Location
or LocationLink
it was computed from.
{locations}
(lsp.Location[]|lsp.LocationLink[]
)
{offset_encoding}
(string
) offset_encoding for locations
utf-8|utf-16|utf-32 default to first client of
buffer
table[]
) A list of objects with the following fields:
{filename}
(string
)
{lnum}
(integer
) 1-indexed line number
{end_lnum}
(integer
) 1-indexed end line number
{col}
(integer
) 1-indexed column
{end_col}
(integer
) 1-indexed end column
{text}
(string
)
{user_data}
(lsp.Location|lsp.LocationLink
)
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().
{width}
(integer
) window width (in character cells)
{height}
(integer
) window height (in character cells)
{opts}
(table
) optional
col
row
border
focusable
zindex
, defaults to 50
table
) Options
vim.lsp.util.make_formatting_params()
make_formatting_params({options}
)
Creates a DocumentFormattingParams
object for the current buffer and
cursor position.
{options}
(lsp.FormattingOptions?
) with valid FormattingOptions
entries
lsp.DocumentFormattingParams
) object
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().
{start_pos}
(integer[]?
) {row,col}
mark-indexed position.
Defaults to the start of the last visual selection.
{end_pos}
(integer[]?
) {row,col}
mark-indexed position.
Defaults to the end of the last visual selection.
{bufnr}
(integer?
) buffer handle or 0 for current,
defaults to current
{offset_encoding}
("utf-8"|"utf-16"|"utf-32"?
) defaults to
offset_encoding
of first client of bufnr
table
) { 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.
{window}
(integer?
) 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
lsp.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
.
{window}
(integer?
) window handle or 0 for current,
defaults to current
{offset_encoding}
("utf-8"|"utf-16"|"utf-32"?
) defaults to
offset_encoding
of first client of buffer of
window
table
) { 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.
{bufnr}
(integer?
) Buffer handle, defaults to current
lsp.TextDocumentIdentifier
)
vim.lsp.util.make_workspace_params()
make_workspace_params({added}
, {removed}
)
Create the workspace params
{added}
(lsp.WorkspaceFolder[]
)
{removed}
(lsp.WorkspaceFolder[]
)
lsp.WorkspaceFoldersChangeEvent
)
vim.lsp.util.open_floating_preview()
open_floating_preview({contents}
, {syntax}
, {opts}
)
Shows contents in a floating window.
{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
filtered with vim.lsp.util.make_floating_popup_options()
before they are passed on to nvim_open_win())
{height}
(integer
) Height of floating window
{width}
(integer
) Width of floating window
{wrap}
(boolean
, default: true
) Wrap long lines
{wrap_at}
(integer
) Character to wrap at for
computing height when wrap is enabled
{max_width}
(integer
) Maximal width of floating
window
{max_height}
(integer
) Maximal height of floating
window
{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}
integer
) bufnr of newly created float window
(integer
) winid of newly created float window preview window
{location}
, {opts}
) vim.lsp.util.preview_location()
Previews a location in a floating window
{location}
(lsp.Location|lsp.LocationLink
)
{opts}
(table
)
integer?
) buffer id of float window
(integer?
) window id of float window
opts
requests overwriting; or
{old_fname}
(string
)
{new_fname}
(string
)
{opts}
(table?
) Options:
{overwrite}
(boolean
)
{ignoreIfExists}
(boolean
)
vim.lsp.util.show_document()
show_document({location}
, {offset_encoding}
, {opts}
)
Shows document and optionally jumps to the location.
{location}
(lsp.Location|lsp.LocationLink
)
{offset_encoding}
(string?
) utf-8|utf-16|utf-32
{opts}
(table?
) options
boolean
) true
if succeeded
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.
open_floating_preview
instead
{bufnr}
(integer
)
{contents}
(string[]
) of lines to show in window
{opts}
(table
) with optional fields
table
) stripped content
{symbols}
, {bufnr}
) vim.lsp.util.symbols_to_items()
Converts symbols to quickfix list items.
{symbols}
(table
) DocumentSymbol[] or SymbolInformation[]
{bufnr}
(integer?
)
vim.lsp.log.get_filename()
Returns the log filename.
string
) log filename
vim.lsp.log.get_level()
Gets the current log level.
integer
) current log level
{handle}
) vim.lsp.log.set_format_func()
Sets formatting function used to format logs
{handle}
(function
) function to apply to logging arguments, pass
vim.inspect for multi-line formatting
{level}
) vim.lsp.log.set_level()
Sets the current log level.
{level}
(string|integer
) One of vim.lsp.log.levels
{level}
) vim.lsp.log.should_log()
Checks whether the level is sufficient for logging.
{level}
(integer
) log level
bool
) true if would log, false if not
{request}
(fun(method: string, params: table?, callback: fun(err: lsp.ResponseError?, result: any), notify_reply_callback: fun(integer)?):boolean,integer?
)
see vim.lsp.rpc.request()
{is_closing}
(fun(): boolean
)
{terminate}
(fun()
)
{host_or_path}
, {port}
) vim.lsp.rpc.connect()
Create a LSP RPC client factory that connects to either:
cmd
field for
vim.lsp.start_client() or vim.lsp.start().
{host_or_path}
(string
) host to connect to or path to a pipe/domain
socket
{port}
(integer?
) TCP port to connect to. If absent the
first argument must be a pipe
fun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient
)
{err}
) vim.lsp.rpc.format_rpc_error()
Constructs an error message from an LSP error object.
{err}
(table
) The error object
string
) error_message The formatted error message
{method}
(string
) The invoked LSP method
{params}
(table?
) Parameters for the invoked LSP method
boolean
) 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.
{method}
(string
) The invoked LSP method
{params}
(table?
) Parameters for the invoked LSP
method
{callback}
(fun(err: lsp.ResponseError?, result: any)
)
Callback to invoke
{notify_reply_callback}
(fun(message_id: integer)?
) Callback to
invoke as soon as a request is no longer
pending
boolean
) success true
if request could be sent, false
if not
(integer?
) message_id if request could be sent, nil
if not
vim.lsp.rpc.rpc_response_error()
rpc_response_error({code}
, {message}
, {data}
)
Creates an RPC response table error
to be sent to the LSP response.
{code}
(integer
) RPC error code defined, see
vim.lsp.protocol.ErrorCodes
{message}
(string?
) arbitrary message to send to server
{data}
(any?
) arbitrary data to send to server
lsp.ResponseError
)
vim.lsp.protocol.ErrorCodes
{cmd}
, {dispatchers}
, {extra_spawn_params}
) vim.lsp.rpc.start()
Starts an LSP server process and create an LSP RPC client object to
interact with it. Communication with the spawned process happens via
stdio. For communication via TCP, spawn a process manually and use
vim.lsp.rpc.connect()
{cmd}
(string[]
) Command to start the LSP server.
{dispatchers}
(table?
) Dispatchers for LSP message types.
{notification}
(fun(method: string, params: table)
)
{server_request}
(fun(method: string, params: table): any?, lsp.ResponseError?
)
{on_exit}
(fun(code: integer, signal: integer)
)
{on_error}
(fun(code: integer, err: any)
)
{extra_spawn_params}
(table?
) Additional context for the LSP server
process.
{cwd}
(string
) Working directory for the
LSP server process
{detached}
(boolean
) Detach the LSP server
process from the current process
{env}
(table<string,string>
) Additional
environment variables for LSP server process.
See vim.system()
vim.lsp.rpc.PublicClient
) Client RPC object, with these methods:
notify()
vim.lsp.rpc.notify()
request()
vim.lsp.rpc.request()
is_closing()
returns a boolean indicating if the RPC is closing.
terminate()
terminates the RPC client. See
vim.lsp.rpc.PublicClient.
vim.lsp.protocol.make_client_capabilities()
make_client_capabilities()
Gets a new ClientCapabilities object describing the LSP client
capabilities.
lsp.ClientCapabilities
)
vim.lsp.protocol.Methods
LSP method names.
vim.lsp.protocol.resolve_capabilities()
resolve_capabilities({server_capabilities}
)
Creates a normalized object describing LSP server capabilities.
{server_capabilities}
(table
) Table of capabilities supported by
the server
lsp.ServerCapabilities?
) Normalized table of capabilities