Nvim :help pages, generated
from source
using the tree-sitter-vimdoc parser.
vim.lsp for building
enhanced LSP tools.
vim.lsp.config['luals'] = {
-- Command and arguments to start the server.
cmd = { 'lua-language-server' },
-- Filetypes to automatically attach to.
filetypes = { 'lua' },
-- Sets the "root directory" to the parent directory of the file in the
-- current buffer that contains either a ".luarc.json" or a
-- ".luarc.jsonc" file. Files that share a root directory will reuse
-- the connection to the same LSP server.
-- Nested lists indicate equal priority, see |vim.lsp.Config|.
root_markers = { { '.luarc.json', '.luarc.jsonc' }, '.git' },
-- Specific settings to send to the server. The schema for this is
-- defined by the server. For example the schema for lua-language-server
-- can be found here https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json
settings = {
Lua = {
runtime = {
version = 'LuaJIT',
}
}
}
}vim.lsp.enable('luals'):checkhealth vim.lspK exists.
CTRL-S is mapped in Insert mode to vim.lsp.buf.signature_help()
vim.api.nvim_create_autocmd('LspAttach', {
callback = function(args)
-- Unset 'formatexpr'
vim.bo[args.buf].formatexpr = nil
-- Unset 'omnifunc'
vim.bo[args.buf].omnifunc = nil
-- Unmap K
vim.keymap.del('n', 'K', { buffer = args.buf })
end,
})'*' name.
2. Configuration from the result of merging all tables returned by
lsp/<name>.lua files in 'runtimepath' for a server of name name.
3. Configurations defined anywhere else.
-- Defined in init.lua
vim.lsp.config('*', {
capabilities = {
textDocument = {
semanticTokens = {
multilineTokenSupport = true,
}
}
},
root_markers = { '.git' },
})
-- Defined in <rtp>/lsp/clangd.lua
return {
cmd = { 'clangd' },
root_markers = { '.clangd', 'compile_commands.json' },
filetypes = { 'c', 'cpp' },
}
-- Defined in init.lua
vim.lsp.config('clangd', {
filetypes = { 'c' },
}){
-- From the clangd configuration in <rtp>/lsp/clangd.lua
cmd = { 'clangd' },
-- From the clangd configuration in <rtp>/lsp/clangd.lua
-- Overrides the "*" configuration in init.lua
root_markers = { '.clangd', 'compile_commands.json' },
-- From the clangd configuration in init.lua
-- Overrides the clangd configuration in <rtp>/lsp/clangd.lua
filetypes = { 'c' },
-- From the "*" configuration in init.lua
capabilities = {
textDocument = {
semanticTokens = {
multilineTokenSupport = true,
}
}
}
}supports_method() in your
LspAttach handler.
lsp-lint lsp-format
Example: Enable auto-completion and auto-formatting ("linting"):vim.api.nvim_create_autocmd('LspAttach', {
group = vim.api.nvim_create_augroup('my.lsp', {}),
callback = function(args)
local client = assert(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
-- Enable auto-completion. Note: Use CTRL-Y to select an item. |complete_CTRL-Y|
if client:supports_method('textDocument/completion') then
-- Optional: trigger autocompletion on EVERY keypress. May be slow!
-- local chars = {}; for i = 32, 126 do table.insert(chars, string.char(i)) end
-- client.server_capabilities.completionProvider.triggerCharacters = chars
vim.lsp.completion.enable(true, client.id, args.buf, {autotrigger = true})
end
-- Auto-format ("lint") on save.
-- Usually not needed if server supports "textDocument/willSaveWaitUntil".
if not client:supports_method('textDocument/willSaveWaitUntil')
and client:supports_method('textDocument/formatting') then
vim.api.nvim_create_autocmd('BufWritePre', {
group = vim.api.nvim_create_augroup('my.lsp', {clear=false}),
buffer = args.buf,
callback = function()
vim.lsp.buf.format({ bufnr = args.buf, id = client.id, timeout_ms = 1000 })
end,
})
end
end,
}):lua =vim.lsp.get_clients()[1].server_capabilities: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 }):lua vim.print(vim.tbl_keys(vim.lsp.handlers))'callHierarchy/incomingCalls'
'callHierarchy/outgoingCalls'
'client/registerCapability'
'client/unregisterCapability'
'signature_help'
'textDocument/codeLens'
'textDocument/completion'
'textDocument/diagnostic'
'textDocument/documentHighlight'
'textDocument/documentSymbol'
'textDocument/formatting'
'textDocument/hover'
'textDocument/inlayHint'
'textDocument/publishDiagnostics'
'textDocument/rangeFormatting'
'textDocument/rename'
'textDocument/signatureHelp'
'typeHierarchy/subtypes'
'typeHierarchy/supertypes'
'window/logMessage'
'window/showDocument'
'window/showMessage'
'window/showMessageRequest'
'window/workDoneProgress/create'
'workspace/applyEdit'
'workspace/configuration'
'workspace/executeCommand'
'workspace/inlayHint/refresh'
'workspace/semanticTokens/refresh'
'workspace/symbol'
'workspace/workspaceFolders'
function(err, result, ctx)
{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.
result, err where err is shaped like an RPC error:{ code, message, data? }
vim.lsp.buf and related interfaces).local client = assert(vim.lsp.get_clients()[1])
client:request('textDocument/definition')vim.lsp.handlers. This global table contains the
default mappings of lsp-method names to handlers. (Note: only for
server-to-client requests/notifications, not client-to-server.)
Example:vim.lsp.handlers['textDocument/publishDiagnostics'] = my_custom_diagnostics_handler{handlers} parameter to vim.lsp.start(). This sets the default
lsp-handler for a specific server. (Note: only for server-to-client
requests/notifications, not client-to-server.)
Example:vim.lsp.start {
..., -- Other configuration omitted.
handlers = {
['textDocument/publishDiagnostics'] = my_custom_diagnostics_handler
},
}{handler} parameter to vim.lsp.buf_request_all(). This sets the
lsp-handler ONLY for the given request(s).
Example:vim.lsp.buf_request_all(
0,
'textDocument/publishDiagnostics',
my_request_params,
my_handler
)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"type such as "function" or "variable", and 0 or more
modifiers 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, {})
endvim.api.nvim_create_autocmd('LspAttach', {
callback = function(ev)
local client = vim.lsp.get_client_by_id(ev.data.client_id)
-- ...
end
})vim.lsp.handlers['client/registerCapability'] = (function(overridden)
return function(err, res, ctx)
local result = overridden(err, res, ctx)
local client = vim.lsp.get_client_by_id(ctx.client_id)
if not client then
return
end
for bufnr, _ in pairs(client.attached_buffers) do
-- Call your custom on_attach logic...
-- my_on_attach(client, bufnr)
end
return result
end
end)(vim.lsp.handlers['client/registerCapability'])vim.api.nvim_create_autocmd('LspDetach', {
callback = function(args)
-- Get the detaching client
local client = vim.lsp.get_client_by_id(args.data.client_id)
-- Remove the autocommand to format the buffer on save, if it exists
if client:supports_method('textDocument/formatting') then
vim.api.nvim_clear_autocmds({
event = 'BufWritePre',
buffer = args.buf,
})
end
end,
})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,
})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).
client_id and params
properties, where params is the request params sent by the server (see
lsp.ProgressParams).
autocmd LspProgress * redrawstatuspending, 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} field). If the request
type is complete, the request will be deleted from the client's pending
requests table after processing the event handlers.
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,
})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,
}){cmd} (string[]|fun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient)
See cmd in vim.lsp.ClientConfig.
{filetypes} (string[]) Filetypes the client will attach to, if
activated by vim.lsp.enable(). If not provided, the
client will attach to all filetypes.
{reuse_client} (fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig): boolean)
Predicate which decides 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.
{root_dir} (string|fun(bufnr: integer, on_dir:fun(root_dir?:string)))
lsp-root_dir() Directory where the LSP server will
base its workspaceFolders, rootUri, and rootPath on
initialization. The function form receives a buffer
number and on_dir callback which it must call to
provide root_dir, or LSP will not be activated for
the buffer. Thus a root_dir() function can
dynamically decide per-buffer whether to activate (or
skip) LSP. See example at vim.lsp.enable().
{root_markers} ((string|string[])[]) Directory markers (.e.g.
'.git/') where the LSP server will base its
workspaceFolders, rootUri, and rootPath on
initialization. Unused if root_dir is provided.
{ { 'a', 'b' }, ... }) Each entry in this list is
a set of one or more markers. For each set, Nvim will
search upwards for each marker contained in the set.
If a marker is found, the directory which contains
that marker is used as the root directory. If no
markers from the set are found, the process is
repeated with the next set in the list.
root_markers = { 'stylua.toml', '.git' }stylua.toml. If not found, find the first parent
directory containing the file or directory .git.
root_markers = { { 'stylua.toml', '.luarc.json' }, '.git' }stylua.toml or .luarc.json. If not found, find
the first parent directory containing the file or
directory .git.
{bufnr}, {client_id}) vim.lsp.buf_attach_client()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(){bufnr} (integer) Buffer handle, or 0 for current
{client_id} (integer) Client id
{bufnr}, {client_id}) vim.lsp.buf_is_attached(){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
{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|(fun(client: vim.lsp.Client, bufnr: integer): table?)?)
Parameters to send to the server. Can also be passed as a
function that returns the params table for cases where
parameters are specific to the client.
{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.
{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|(fun(client: vim.lsp.Client, bufnr: integer): table?)?)
Parameters to send to the server. Can also be passed as
a function that returns the params table for cases where
parameters are specific to the client.
{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.
vim.lsp.commands, the command will be executed via the LSP server using
workspace/executeCommand.
Command:
Command title: String command: String arguments?: any[]
ctx.
vim.lsp.commands['java.action.generateToStringPrompt'] = function(_, ctx)
require("jdtls.async").run(function()
local _, result = request(ctx.bufnr, 'java/checkToStringStatus', ctx.params)
local fields = ui.pick_many(result.fields, 'Include item in toString?', function(x)
return string.format('%s: %s', x.name, x.type)
end)
local _, edit = request(ctx.bufnr, 'java/generateToString', { context = ctx.params; fields = fields; })
vim.lsp.util.apply_workspace_edit(edit, offset_encoding)
end)
end{name}, {cfg}) vim.lsp.config()vim.lsp.config[…]) to get the
resolved config, or redefine the config (instead of "merging" with the
config chain).
vim.lsp.config('*', {
root_markers = { '.git', '.hg' },
}) vim.lsp.config('*', {
capabilities = {
textDocument = {
semanticTokens = {
multilineTokenSupport = true,
}
}
}
}) vim.lsp.config('clangd', {
root_markers = { '.clang-format', 'compile_commands.json' },
capabilities = {
textDocument = {
completion = {
completionItem = {
snippetSupport = true,
}
}
}
}
}) vim.lsp.config.clangd = {
cmd = {
'clangd',
'--clang-tidy',
'--background-index',
'--offset-encoding=utf-8',
},
root_markers = { '.clangd', 'compile_commands.json' },
filetypes = { 'c', 'cpp' },
}local cfg = vim.lsp.config.luals{name}, {enable}) vim.lsp.enable()filetypes, root_markers, and root_dir fields.
vim.lsp.enable('clangd')
vim.lsp.enable({'luals', 'pyright'})on_dir() only when you want that
config to activate:vim.lsp.config('lua_ls', {
root_dir = function(bufnr, on_dir)
if not vim.fn.bufname(bufnr):match('%.txt$') then
on_dir(vim.fn.getcwd())
end
end
}){name} (string|string[]) Name(s) of client(s) to enable.
{enable} (boolean?) true|nil to enable, false to disable.
{kind}, {winid}) vim.lsp.foldclose(){kind} of folds in the the window with {winid}.
vim.api.nvim_create_autocmd('LspNotify', {
callback = function(args)
if args.data.method == 'textDocument/didOpen' then
vim.lsp.foldclose('imports', vim.fn.bufwinid(args.buf))
end
end,
}){kind} (lsp.FoldingRangeKind) Kind to close, one of "comment",
"imports" or "region".
{winid} (integer?) Defaults to the current window.
{lnum}) vim.lsp.foldexpr()foldexpr
function.
vim.o.foldmethod = 'expr'
vim.o.foldexpr = 'v:lua.vim.lsp.foldexpr()'vim.o.foldmethod = 'expr'
-- Default to treesitter folding
vim.o.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
-- Prefer LSP folding if client supports it
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/foldingRange') then
local win = vim.api.nvim_get_current_win()
vim.wo[win][0].foldexpr = 'v:lua.vim.lsp.foldexpr()'
end
end,
}){lnum} (integer) line number
foldtext function that shows the collapsedText retrieved,
defaults to the first folded line if collapsedText is not provided.
{opts}) vim.lsp.formatexpr()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..
{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(){client_id} (integer) client id
vim.lsp.Client?) client rpc object
{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
string) path to log file
{name}) vim.lsp.is_enabled(){name} (string) Config name
boolean)
{findstart} (integer) 0 or 1, decides behavior
{base} (integer) findstart=0, text to match against
integer|table) Decided by {findstart}:
lsp.log_levels for reverse lookup.
{level} (integer|string) the case insensitive level name or number
{config}, {opts}) vim.lsp.start()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.
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() 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 it has the same name and if the given
workspace folders (or root_dir) are all included in the
client's workspace folders.
{bufnr} (integer) Buffer handle to attach to if
starting or re-using a client (0 for current).
{attach} (boolean) Whether to attach the client to a
buffer (default true). If set to false, reuse_client
and bufnr will be ignored.
{silent} (boolean) Suppress error reporting if the LSP
server fails to start (default false).
integer?) client_id
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(){pattern} (string) Pattern used to find a workspace symbol
table[]) tags A list of matching tags
{attached_buffers} (table<integer,true>)
{capabilities} (lsp.ClientCapabilities) Capabilities
provided by the client (editor or tool), at
startup.
{commands} (table<string,fun(command: lsp.Command, ctx: table)>)
Client commands. See vim.lsp.ClientConfig.
{config} (vim.lsp.ClientConfig) Copy of the config
passed to vim.lsp.start(). See
vim.lsp.ClientConfig.
{dynamic_capabilities} (lsp.DynamicCapabilities) Capabilities
provided at runtime (after startup).
{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.
{id} (integer) The id allocated to the client.
{initialized} (true?)
{progress} (vim.lsp.Client.Progress) A ring buffer
(vim.ringbuf()) containing progress messages
sent by the server. See
vim.lsp.Client.Progress.
{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.
{rpc} (vim.lsp.rpc.PublicClient) RPC client
object, for low level interaction with the
client. See vim.lsp.rpc.start().
{server_capabilities} (lsp.ServerCapabilities?) Response from the
server sent on initialize describing the
server's capabilities.
{server_info} (lsp.ServerInfo?) Response from the server
sent on initialize describing server
information (e.g. version).
{request} (fun(self: vim.lsp.Client, method: string, params: table?, handler: lsp.Handler?, bufnr: integer?): boolean, integer?)
See Client:request().
{request_sync} (fun(self: vim.lsp.Client, method: string, params: table, timeout_ms: integer?, bufnr: integer?): {err: lsp.ResponseError?, result:any}?, string?)
See Client:request_sync().
{exec_cmd} (fun(self: vim.lsp.Client, command: lsp.Command, context: {bufnr?: integer}?, handler: lsp.Handler?))
See Client:exec_cmd().
{supports_method} (fun(self: vim.lsp.Client, method: string, bufnr: integer?))
See Client:supports_method().
{pending} (table<lsp.ProgressToken,lsp.LSPAny>)
{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().
You can use this to modify parameters before
they are sent.
{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.
{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 variables passed to the
LSP process on spawn. Non-string values are
coerced to string. Example:{ PORT = 8080; HOST = '0.0.0.0'; }{commands} (table<string,fun(command: lsp.Command, ctx: table)>)
Client commands. Map of command names to
user-defined functions. Commands passed to
start() 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.
{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.
{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)
Language ID as string. Defaults to the buffer
filetype.
{init_options} (lsp.LSPObject) Values to pass in the
initialization request as
initializationOptions. See initialize in
the LSP spec.
{name} (string) (default: client-id) Name in logs
and user messages.
{offset_encoding} ('utf-8'|'utf-16'|'utf-32') Called "position
encoding" in LSP spec. The encoding that the
LSP server expects, used for communication. Not
validated. Can be modified in on_init before
text is sent to the server.
{on_attach} (elem_or_list<fun(client: vim.lsp.Client, bufnr: integer)>)
Callback invoked when client attaches to a
buffer.
{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.
{on_exit} (elem_or_list<fun(code: integer, signal: integer, client_id: integer)>)
Callback invoked on client exit.
{on_init} (elem_or_list<fun(client: vim.lsp.Client, init_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 init_result.offsetEncoding if
capabilities.offsetEncoding was sent to it.
You can only modify the
client.offset_encoding here before any
notifications are sent.
{root_dir} (string) Directory where the LSP server will
base its workspaceFolders, rootUri, and
rootPath on initialization.
{settings} (lsp.LSPObject) Map of language
server-specific settings, decided by the
client. Sent to the LS if requested via
workspace/configuration. Keys are
case-sensitive.
{trace} ('off'|'messages'|'verbose', default: "off")
Passed directly to the language server in the
initialize request. Invalid/empty values will
{workspace_folders} (lsp.WorkspaceFolder[]) List of workspace
folders passed to the language server. For
backwards compatibility rootUri and rootPath
are derived from the first workspace folder in
this list. Can be null if the client supports
workspace folders but none are configured. See
workspaceFolders in LSP spec.
{workspace_required} (boolean) (default false) Server requires a
workspace (no "single file" support). Note:
Without a workspace, cross-file features
(navigation, hover) may or may not work
depending on the language server, even if the
server doesn't require a workspace.
{id} (integer) id of request to cancel
boolean) status indicating if the notification was successful.
{command}, {context}, {handler}) Client:exec_cmd(){command} (lsp.Command)
{context} ({bufnr?: integer}?)
{handler} (lsp.Handler?) only called if a server command
boolean) true if client is stopped or in the process of being
stopped; false otherwise
{method} (string) LSP method name.
{params} (table?) LSP request params.
boolean) status indicating if the notification was successful. If
it is false, then the client has shutdown.
{bufnr}) Client:on_attach(){bufnr} (integer) Buffer number
{method}, {params}, {handler}, {bufnr})
Sends a request to the server.
{client.rpc.request} with some additional
checks for capabilities and handler availability.
{method} (string) LSP method name.
{params} (table?) LSP request params.
{bufnr} (integer?) (default: 0) Buffer handle, or 0 for current.
boolean) status indicates whether the request was successful. If it
is false, then it will always be false (the client has shutdown).
(integer?) request_id Can be used with Client:cancel_request().
nil is request failed.
{method}, {params}, {timeout_ms}, {bufnr})
Sends a request to the server and synchronously waits for the response.
{method} (string) LSP method name.
{params} (table) LSP request params.
{timeout_ms} (integer?) Maximum time in milliseconds to wait for a
result. Defaults to 1000
{bufnr} (integer?) (default: 0) Buffer handle, or 0 for
current.
{err: lsp.ResponseError?, result:any}?) result and err from the
lsp-handler. nil is the request was unsuccessful
(string?) err On timeout, cancel or error, where err is a string
describing the failure reason.
{force} (boolean?)
{method}, {bufnr}) Client:supports_method(){method} (string)
{bufnr} (integer?)
vim.lsp.buf_… functions perform operations for LSP clients attached to
the current buffer.
{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 }){loclist} (boolean) Whether to use the location-list or the
quickfix list in the default handler.vim.lsp.buf.definition({ loclist = true })
vim.lsp.buf.references(nil, { loclist = false }){reuse_win} (boolean) Jump to existing window if buffer is already
open.
{title} (string) Title for the list.
{silent} (boolean)
{silent} (boolean)
{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?)
{opts}) vim.lsp.buf.code_action(){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 CodeActionKinds 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
{opts}) vim.lsp.buf.declaration()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(){opts}) vim.lsp.buf.format(){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 ~= "ts_ls" 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.
{config}) vim.lsp.buf.hover()vim.api.nvim_create_autocmd('ColorScheme', {
callback = function()
vim.api.nvim_set_hl(0, 'LspReferenceTarget', {})
end,
}){opts}) vim.lsp.buf.implementation(){context}, {opts}) vim.lsp.buf.references(){context} (lsp.ReferenceContext?) Context for the request
{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(){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)
{config}) vim.lsp.buf.signature_help(){opts}) vim.lsp.buf.type_definition(){kind}) vim.lsp.buf.typehierarchy(){kind} ("subtypes"|"supertypes")
{query}, {opts}) vim.lsp.buf.workspace_symbol(){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()vim.Diagnostics to LSP diagnostics.
{diagnostics} (vim.Diagnostic[])
lsp.Diagnostic[])
{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
{error}, {result}, {ctx})
lsp-handler for the method "textDocument/diagnostic"
{error} (lsp.ResponseError?)
{result} (lsp.DocumentDiagnosticReport)
{ctx} (lsp.HandlerContext)
{_}, {params}, {ctx})
lsp-handler for the method "textDocument/publishDiagnostics"
{params} (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(){lenses} (lsp.CodeLens[]?) lenses to display
{bufnr} (integer)
{client_id} (integer)
{bufnr} (integer) Buffer number. 0 can be used for the current
buffer.
lsp.CodeLens[])
{err}, {result}, {ctx}) vim.lsp.codelens.on_codelens()textDocument/codeLens
{err} (lsp.ResponseError?)
{result} (lsp.CodeLens[])
{ctx} (lsp.HandlerContext)
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
{lenses}, {bufnr}, {client_id}) vim.lsp.codelens.save(){lenses} (lsp.CodeLens[]?) lenses to store
{bufnr} (integer)
{client_id} (integer)
vim.lsp.completion module enables insert-mode completion driven by an
LSP server. Call enable() to make it available through Nvim builtin
completion (via the CompleteDone event). Specify autotrigger=true to
activate "auto-completion" when you type any of the server-defined
triggerCharacters. Use CTRL-Y to select an item from the completion menu.
complete_CTRL-Y
-- Works best with completeopt=noselect.
-- Use CTRL-Y to select an item. |complete_CTRL-Y|
vim.cmd[[set completeopt+=menuone,noselect,popup]]
vim.lsp.start({
name = 'ts_ls',
cmd = …,
on_attach = function(client, bufnr)
vim.lsp.completion.enable(true, client.id, bufnr, {
autotrigger = true,
convert = function(item)
return { abbr = item.label:gsub('%b()', '') }
end,
})
end,
})triggerCharacters field decides when to trigger autocompletion. If
you want to trigger on EVERY keypress you can either:
client.server_capabilities.completionProvider.triggerCharacters on
LspAttach, before you call
vim.lsp.completion.enable(… {autotrigger=true}). See the lsp-attach
example.
vim.lsp.completion.get() from the handler described at
compl-autocomplete.
{enable}, {client_id}, {bufnr}, {opts})
Enables or disables completions from the given language client in the
given buffer. Effects of enabling completions are:
<c-y> applies side effects like
expanding snippets, text edits (e.g. insert import statements) and
executing associated commands. This works for completions triggered via
autotrigger, omnifunc or completion.get()
autotrigger=true is controlled by the LSP
triggerCharacters field. You can override it on LspAttach, see
lsp-autocompletion.
{enable} (boolean) True to enable, false to disable
{client_id} (integer) Client ID
{bufnr} (integer) Buffer handle, or 0 for the current buffer
{opts} (table?) A table with the following fields:
{autotrigger} (boolean) (default: false) When true,
completion triggers automatically based on the server's
triggerCharacters.
{convert} (fun(item: lsp.CompletionItem): table)
Transforms an LSP CompletionItem to complete-items.
{opts}) vim.lsp.completion.get()CTRL-Y to
select an item from the completion menu. complete_CTRL-Y
CTRL-space, use this mapping:-- Use CTRL-space to trigger LSP completion.
-- Use CTRL-Y to select an item. |complete_CTRL-Y|
vim.keymap.set('i', '<c-space>', function()
vim.lsp.completion.get()
end){opts} (table?) A table with the following fields:
{ctx} (lsp.CompletionContext) Completion context.
Defaults to a trigger kind of invoked.
{enable}, {filter}) vim.lsp.inlay_hint.enable(){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()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(){filter}ed scope
{bufnr} (integer?) Buffer number, or 0 for current
buffer, or nil for all.
boolean)
{bufnr}) vim.lsp.semantic_tokens.force_refresh(){bufnr} (integer?) filter by buffer. All buffers if nil, current
buffer if 0
{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:
{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.hl.priorities.semantic_tokens + 3) Priority for
the applied extmark.
{bufnr}, {client_id}, {opts}) vim.lsp.semantic_tokens.start(){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()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
{enable}, {bufnr}, {opts}) vim.lsp.document_color.enable()vim.api.nvim_create_autocmd('LspAttach', {
callback = function(args)
vim.lsp.document_color.enable(true, args.buf)
end
})is_enabled():vim.lsp.document_color.enable(not vim.lsp.document_color.is_enabled()){enable} (boolean?) True to enable, false to disable. (default:
true)
{bufnr} (integer?) Buffer handle, or 0 for current. (default: 0)
{opts} (table?) A table with the following fields:
{style}
('background'|'foreground'|'virtual'|string|fun(bufnr: integer, range: Range4, hex_code: string))
Highlight style. It can be one of the pre-defined styles,
a string to be used as virtual text, or a function that
receives the buffer handle, the range (start line, start
col, end line, end col) and the resolved hex color.
(default: 'background')
{bufnr}) vim.lsp.document_color.is_enabled(){bufnr} (integer?) Buffer handle, or 0 for current. (default: 0)
boolean)
{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}
{offset_x} (integer) offset to add to col
{offset_y} (integer) offset to add to row
{border} (string|(string|[string,string])[]) override
border
{zindex} (integer) override zindex, defaults to 50
{title} (string|[string,string][])
{title_pos} ('left'|'center'|'right')
{relative} ('mouse'|'cursor'|'editor') (default: 'cursor')
{anchor_bias} ('auto'|'above'|'below', default: 'auto') Adjusts
placement relative to cursor.
{text_document_edit}, {index}, {position_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)
{position_encoding} ('utf-8'|'utf-16'|'utf-32'?)
{text_edits}, {bufnr}, {position_encoding})
Applies a list of text edits to a buffer.
{text_edits} (lsp.TextEdit[])
{bufnr} (integer) Buffer id
{position_encoding} ('utf-8'|'utf-16'|'utf-32')
{workspace_edit}, {position_encoding})
Applies a WorkspaceEdit.
{workspace_edit} (lsp.WorkspaceEdit)
{position_encoding} ('utf-8'|'utf-16'|'utf-32') (required)
{bufnr}) vim.lsp.util.buf_clear_references(){bufnr} (integer?) Buffer id
{bufnr}, {references}, {position_encoding})
Shows a list of document highlights for a certain buffer.
{bufnr} (integer) Buffer id
{references} (lsp.DocumentHighlight[]) objects to highlight
{position_encoding} ('utf-8'|'utf-16'|'utf-32')
{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} ('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}
{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.
{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} (string[]?) list of trigger characters from the
lsp server. used to better determine parameter
offsets
string[]?) lines of converted markdown.
(Range4?) highlight range for the active parameter
{bufnr} (integer?) Buffer handle, defaults to current
integer) indentation size
{locations}, {position_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[])
{position_encoding} ('utf-8'|'utf-16'|'utf-32'?) default to first
client of buffer
{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)
vim.api.keyset.win_config)
{options})
Creates a DocumentFormattingParams object for the current buffer and
cursor position.
{options} (lsp.FormattingOptions?) with valid FormattingOptions
entries
lsp.DocumentFormattingParams) object
{start_pos}, {end_pos}, {bufnr}, {position_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,integer]?) {row,col} mark-indexed
position. Defaults to the start of the last
visual selection.
{end_pos} ([integer,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
{position_encoding} ('utf-8'|'utf-16'|'utf-32')
{ textDocument: { uri: lsp.DocumentUri }, range: lsp.Range })
{window}, {position_encoding})
Creates a TextDocumentPositionParams object for the current buffer and
cursor position.
{position_encoding} ('utf-8'|'utf-16'|'utf-32')
lsp.TextDocumentPositionParams)
{window}, {position_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.
{position_encoding} ("utf-8"|"utf-16"|"utf-32")
{ textDocument: { uri: lsp.DocumentUri }, range: lsp.Range })
{bufnr})
Creates a TextDocumentIdentifier object for the current buffer.
{bufnr} (integer?) Buffer handle, defaults to current
lsp.TextDocumentIdentifier)
{added}, {removed})
Create the workspace params
{added} (lsp.WorkspaceFolder[])
{removed} (lsp.WorkspaceFolder[])
lsp.WorkspaceFoldersChangeEvent)
{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} (vim.lsp.util.open_floating_preview.Opts?) with optional
fields (additional keys are filtered with
vim.lsp.util.make_floating_popup_options() before they
are passed on to nvim_open_win()). See
vim.lsp.util.open_floating_preview.Opts.
integer) bufnr of newly created float window
(integer) winid of newly created float window preview window
{location}, {opts}) vim.lsp.util.preview_location(){location} (lsp.Location|lsp.LocationLink)
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)
{location}, {position_encoding}, {opts})
Shows document and optionally jumps to the location.
{location} (lsp.Location|lsp.LocationLink)
{position_encoding} ('utf-8'|'utf-16'|'utf-32'?)
{opts} (table?) A table with the following fields:
{reuse_win} (boolean) Jump to existing
window if buffer is already open.
{focus} (boolean) Whether to focus/jump to
location if possible. (defaults: true)
boolean) true if succeeded
{symbols}, {bufnr}, {position_encoding})
Converts symbols to quickfix list items.
{symbols} (lsp.DocumentSymbol[]|lsp.SymbolInformation[])
list of symbols
{bufnr} (integer?) buffer handle or 0 for current,
defaults to current
{position_encoding} ('utf-8'|'utf-16'|'utf-32'?) default to first
client of buffer
vim.lsp.log module provides logging for the Nvim LSP client.
vim.lsp.set_log_level 'trace'
require('vim.lsp.log').set_format_func(vim.inspect):lua vim.cmd('tabnew ' .. vim.lsp.get_log_path()):LspLog if you have nvim-lspconfig installed.)
string) log filename
integer) current log level
{handle}) vim.lsp.log.set_format_func(){handle} (function) function to apply to logging arguments, pass
vim.inspect for multi-line formatting
{level} (integer) log level
boolean) true if would log, false if not
{request} (fun(method: string, params: table?, callback: fun(err?: lsp.ResponseError, result: any), notify_reply_callback?: fun(message_id: integer)):boolean,integer?)
See vim.lsp.rpc.request()
{is_closing} (fun(): boolean) Indicates if the RPC is closing.
{terminate} (fun()) Terminates the RPC client.
{host_or_path}, {port}) vim.lsp.rpc.connect()cmd field for
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(){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
{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
{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()
lsp.ClientCapabilities)
{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