Lsp

Nvim :help pages, generated from source using the tree-sitter-vimdoc parser.


LSP client/framework LSP
Nvim supports the Language Server Protocol (LSP), which means it acts as a client to LSP servers and includes a Lua framework vim.lsp for building enhanced LSP tools.
LSP facilitates features like go-to-definition, find-references, hover, completion, rename, format, refactor, etc., using semantic whole-project analysis (unlike ctags).

QUICKSTART lsp-quickstart

Nvim provides an LSP client, but the servers are provided by third parties. Follow these steps to get LSP features:
1. Install language servers using your package manager or by following the upstream installation instruction.
A list of language servers is available at:
2. Configure the LSP client per language server. A minimal example:
vim.lsp.start({
  name = 'my-server-name',
  cmd = {'name-of-language-server-executable'},
  root_dir = vim.fs.dirname(vim.fs.find({'setup.py', 'pyproject.toml'}, { upward = true })[1]),
})
See vim.lsp.start() for details.
3. Configure keymaps and autocmds to utilize LSP features. See lsp-config.
lsp-config
Starting a LSP client will automatically report diagnostics via vim.diagnostic. Read vim.diagnostic.config() to learn how to customize the display.
It also sets some buffer options if the options are otherwise empty and if the language server supports the functionality.
'omnifunc' is set to vim.lsp.omnifunc(). This allows to trigger completion using i_CTRL-X_CTRL-O
'tagfunc' is set to vim.lsp.tagfunc(). This enables features like go-to-definition, :tjump, and keymaps like CTRL-], CTRL-W_], CTRL-W_} to utilize the language server.
'formatexpr' is set to vim.lsp.formatexpr() if both 'formatprg' and 'formatexpr' are empty. This allows to format lines via gq if the language server supports it.
To use other LSP features like hover, rename, etc. you can setup some additional keymaps. It's recommended to setup them in a LspAttach autocmd to ensure they're only active if there is a LSP client running. An example:
vim.api.nvim_create_autocmd('LspAttach', {
  callback = function(args)
    vim.keymap.set('n', 'K', vim.lsp.buf.hover, { buffer = args.buf })
  end,
})
The most used functions are:
Not all language servers provide the same capabilities. To ensure you only set keymaps if the language server supports a feature, you can guard the keymap calls behind capability checks:
vim.api.nvim_create_autocmd('LspAttach', {
  callback = function(args)
    local client = vim.lsp.get_client_by_id(args.data.client_id)
    if client.server_capabilities.hoverProvider then
      vim.keymap.set('n', 'K', vim.lsp.buf.hover, { buffer = args.buf })
    end
  end,
})
To learn what capabilities are available you can run the following command in a buffer with a started LSP client:
:lua =vim.lsp.get_active_clients()[1].server_capabilities
Full list of features provided by default can be found in lsp-buf.

FAQ lsp-faq

Q: How to force-reload LSP? A: Stop all clients, then reload the buffer.
:lua vim.lsp.stop_client(vim.lsp.get_active_clients())
:edit
Q: Why isn't completion working? A: In the buffer where you want to use LSP, check that 'omnifunc' is set to "v:lua.vim.lsp.omnifunc":
:verbose set omnifunc?
Some other plugin may be overriding the option. To avoid that, you could set the option in an after-directory ftplugin, e.g. "after/ftplugin/python.vim".
Q: How do I run a request synchronously (e.g. for formatting on file save)? A: Check if the function has an 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
Q: How do LSP and Treesitter compare? A: LSP requires a client and language server. The language server uses semantic analysis to understand code at a project level. This provides language servers with the ability to rename across files, find definitions in external libraries and more.
Treesitter is a language parsing library that provides excellent tools for incrementally parsing text and handling errors. This makes it a great fit for editors to understand the contents of the current file for things like syntax highlighting, simple goto-definitions, scope analysis and more.
LSP and Treesitter are both great tools for editing and inspecting code.

LSP API lsp-api

LSP core API is described at lsp-core. Those are the core functions for creating and managing clients.
The vim.lsp.buf_… functions perform operations for all LSP clients attached to the given buffer. lsp-buf
LSP request/response handlers are implemented as Lua functions (see lsp-handler). The vim.lsp.handlers table defines default handlers used when creating a new client. Keys are LSP method names:
:lua print(vim.inspect(vim.tbl_keys(vim.lsp.handlers)))
lsp-method
Methods are the names of requests and notifications as defined by the LSP specification. These LSP requests/notifications are defined by default:
callHierarchy/incomingCalls callHierarchy/outgoingCalls textDocument/codeAction textDocument/completion textDocument/declaration* textDocument/definition textDocument/documentHighlight textDocument/documentSymbol textDocument/formatting textDocument/hover textDocument/implementation* textDocument/publishDiagnostics textDocument/rangeFormatting textDocument/references textDocument/rename textDocument/signatureHelp textDocument/typeDefinition* window/logMessage window/showMessage window/showDocument window/showMessageRequest workspace/applyEdit workspace/symbol
NOTE: These are sometimes not implemented by servers.
lsp-handler
lsp-handlers are functions with special signatures that are designed to handle responses and notifications from LSP servers.
Forlsp-request, each lsp-handler has this signature:
function(err, result, ctx, config)
Parameters:
{err} (table|nil) When the language server is unable to complete a request, a table with information about the error is sent. Otherwise, it is nil. See lsp-response. {result} (Result | Params | nil) When the language server is able to successfully complete a request, this contains the result key of the response. See lsp-response. {ctx} (table) Context describes additional calling state associated with the handler. It consists of the following key, value pairs:
{method} (string) The lsp-method name. {client_id} (number) The ID of the vim.lsp.client. {bufnr} (Buffer) Buffer handle, or 0 for current. {params} (table|nil) The parameters used in the original request which resulted in this handler call. {config} (table) Configuration for the handler.
Each handler can define its own configuration table that allows users to customize the behavior of a particular handler.
To configure a particular lsp-handler, see: lsp-handler-configuration
Returns:
The lsp-handler can respond by returning two values: result, err Where err must be shaped like an RPC error: { code, message, data? }
You can use vim.lsp.rpc.rpc_response_error() to create this object.
For lsp-notification, each lsp-handler has this signature:
function(err, result, ctx, config)
Parameters:
{err} (nil) This is always nil. See lsp-notification {result} (Result) This contains the params key of the notification. See lsp-notification {ctx} (table) Context describes additional calling state associated with the handler. It consists of the following key, value pairs:
{method} (string) The lsp-method name. {client_id} (number) The ID of the vim.lsp.client. {config} (table) Configuration for the handler.
Each handler can define its own configuration table that allows users to customize the behavior of a particular handler.
To configure a particular lsp-handler, see: lsp-handler-configuration
Returns:
The lsp-handler's return value will be ignored.
lsp-handler-configuration
To configure the behavior of a builtin lsp-handler, the convenient method vim.lsp.with() is provided for users.
To configure the behavior of vim.lsp.diagnostic.on_publish_diagnostics(), consider the following example, where a new lsp-handler is created using vim.lsp.with() that no longer generates signs for the diagnostics:
vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
  vim.lsp.diagnostic.on_publish_diagnostics, {
    -- Disable signs
    signs = false,
  }
)
To enable signs, use vim.lsp.with() again to create and assign a new lsp-handler to vim.lsp.handlers for the associated method:
vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
  vim.lsp.diagnostic.on_publish_diagnostics, {
    -- Enable signs
    signs = true,
  }
)
To configure a handler on a per-server basis, you can use the {handlers} key for vim.lsp.start_client()
vim.lsp.start_client {
  ..., -- Other configuration omitted.
  handlers = {
    ["textDocument/publishDiagnostics"] = vim.lsp.with(
      vim.lsp.diagnostic.on_publish_diagnostics, {
        -- Disable virtual_text
        virtual_text = false,
      }
    ),
  },
}
or if using 'nvim-lspconfig', you can use the {handlers} key of setup():
require('lspconfig').rust_analyzer.setup {
  handlers = {
    ["textDocument/publishDiagnostics"] = vim.lsp.with(
      vim.lsp.diagnostic.on_publish_diagnostics, {
        -- Disable virtual_text
        virtual_text = false
      }
    ),
  }
}
Some handlers do not have an explicitly named handler function (such as ||vim.lsp.diagnostic.on_publish_diagnostics()|). To override these, first create a reference to the existing handler:
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:
Setting a field in vim.lsp.handlers. 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
The {handlers} parameter for vim.lsp.start_client(). This will set the lsp-handler as the default handler for this server.
For example:
vim.lsp.start_client {
  ..., -- Other configuration omitted.
  handlers = {
    ["textDocument/definition"] = my_custom_server_definition
  },
}
The {handler} parameter forvim.lsp.buf_request(). This will set the lsp-handler ONLY for the current request.
For example:
vim.lsp.buf_request(
  0,
  "textDocument/definition",
  definition_params,
  my_request_custom_definition
)
In summary, the lsp-handler will be chosen based on the current lsp-method in the following order:
1. Handler passed tovim.lsp.buf_request(), if any. 2. Handler defined in vim.lsp.start_client(), if any. 3. Handler defined in vim.lsp.handlers, if any.
vim.lsp.log_levels Log levels are defined in vim.log.levels

VIM.LSP.PROTOCOL vim.lsp.protocol

Module vim.lsp.protocol defines constants dictated by the LSP specification, and helper functions for creating protocol-related objects. https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.md
For example vim.lsp.protocol.ErrorCodes allows reverse lookup by number or name:
vim.lsp.protocol.TextDocumentSyncKind.Full == 1
vim.lsp.protocol.TextDocumentSyncKind[1] == "Full"
lsp-on-list-handler
on_list receives a table with:
items table[], structured like setqflist-what
title string, title for the list.
context table|nil. ctx from lsp-handler
This table can be used with vim.fn.setqflist or vim.fn.setloclist. E.g.:
local function on_list(options)
  vim.fn.setqflist({}, ' ', options)
  vim.api.nvim_command('cfirst')
end

vim.lsp.buf.definition{on_list=on_list}
vim.lsp.buf.references(nil, {on_list=on_list})
If you prefer loclist do something like this:
local function on_list(options)
  vim.fn.setloclist(0, {}, ' ', options)
  vim.api.nvim_command('lopen')
end

LSP HIGHLIGHT lsp-highlight

Reference Highlights:
Highlight groups that are meant to be used by vim.lsp.buf.document_highlight().
hl-LspReferenceText LspReferenceText used for highlighting "text" references hl-LspReferenceRead LspReferenceRead used for highlighting "read" references hl-LspReferenceWrite LspReferenceWrite used for highlighting "write" references
lsp-highlight-codelens
Highlight groups related to lsp-codelens functionality.
hl-LspCodeLens LspCodeLens Used to color the virtual text of the codelens. See nvim_buf_set_extmark().
LspCodeLensSeparator hl-LspCodeLensSeparator Used to color the separator between two or more code lenses.
lsp-highlight-signature
Highlight groups related to vim.lsp.handlers.signature_help().
hl-LspSignatureActiveParameter LspSignatureActiveParameter Used to highlight the active parameter in the signature help. See vim.lsp.handlers.signature_help().

EVENTS lsp-events

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.server_capabilities.completionProvider then
      vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
    end
    if client.server_capabilities.definitionProvider 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,
})
Also the following User autocommands are provided:
LspProgressUpdate LspProgressUpdate Upon receipt of a progress notification from the server. See vim.lsp.util.get_progress_messages().
LspRequest LspRequest After a change to the active set of pending LSP requests. See {requests} in vim.lsp.client.
Example:
autocmd User LspProgressUpdate redrawstatus
autocmd User LspRequest redrawstatus

Lua module: vim.lsp lsp-core

buf_attach_client({bufnr}, {client_id}) vim.lsp.buf_attach_client() Implements the textDocument/did… notifications required to track a buffer for any language server.
Without calling this, the server won't be notified of changes to a buffer.
Parameters:
{bufnr} (number) Buffer handle, or 0 for current
{client_id} (number) Client id
buf_detach_client({bufnr}, {client_id}) vim.lsp.buf_detach_client() Detaches client from the specified buffer. Note: While the server is notified that the text document (buffer) was closed, it is still able to send notifications should it ignore this notification.
Parameters:
{bufnr} (number) Buffer handle, or 0 for current
{client_id} (number) Client id
buf_is_attached({bufnr}, {client_id}) vim.lsp.buf_is_attached() Checks if a buffer is attached for a particular client.
Parameters:
{bufnr} (number) Buffer handle, or 0 for current
{client_id} (number) the client id
buf_notify({bufnr}, {method}, {params}) vim.lsp.buf_notify() Send a notification to a server
Parameters:
{bufnr} [number] (optional): The number of the buffer
{method} [string]: Name of the request method
{params} [string]: Arguments to send to the server
Return:
true if any client returns true; false otherwise
vim.lsp.buf_request_all() buf_request_all({bufnr}, {method}, {params}, {callback}) Sends an async request for all active clients attached to the buffer. Executes the callback on the combined result. Parameters are the same as vim.lsp.buf_request() but the return result and callback are different.
Parameters:
{bufnr} (number) Buffer handle, or 0 for current.
{method} (string) LSP method name
{params} (optional, table) Parameters to send to the server
{callback} (function) The callback to call when all requests are finished.
Return:
(function) A function that will cancel all requests which is the same as the one returned from buf_request.
vim.lsp.buf_request_sync() buf_request_sync({bufnr}, {method}, {params}, {timeout_ms}) Sends a request to all server and waits for the response of all of them.
Calls vim.lsp.buf_request_all() but blocks Nvim while awaiting the result. Parameters are the same asvim.lsp.buf_request() but the return result is different. Wait maximum of {timeout_ms} (default 1000) ms.
Parameters:
{bufnr} (number) Buffer handle, or 0 for current.
{method} (string) LSP method name
{params} (optional, table) Parameters to send to the server
{timeout_ms} (optional, number, default=1000) Maximum time in milliseconds to wait for a result.
Return:
Map of client_id:request_result. On timeout, cancel or error, returns (nil, err) where err is a string describing the failure reason.
client() vim.lsp.client LSP client object. You can get an active client object via vim.lsp.get_client_by_id() or vim.lsp.get_active_clients().
Methods:
request(method, params, [handler], bufnr) Sends a request to the server. This is a thin wrapper around {client.rpc.request} with some additional checking. If {handler} is not specified, If one is not found there, then an error will occur. Returns: {status}, {[client_id]}. {status} is a boolean indicating if the notification was successful. If it is false, then it will always be false (the client has shutdown). If {status} is true, the function returns {request_id} as the second result. You can use this with client.cancel_request(request_id) to cancel the request.
request_sync(method, params, timeout_ms, bufnr) Sends a request to the server and synchronously waits for the response. This is a wrapper around {client.request} Returns: { err=err, result=result }, a dictionary, where err and result come from the lsp-handler. On timeout, cancel or error, returns (nil, err) where err is a string describing the failure reason. If the request was unsuccessful returns nil.
notify(method, params) Sends a notification to an LSP server. Returns: a boolean to indicate if the notification was successful. If it is false, then it will always be false (the client has shutdown).
cancel_request(id) Cancels a request with a given request id. Returns: same as notify().
stop([force]) Stops a client, optionally with force. By default, it will just ask the server to shutdown without force. If you request to stop a client which has previously been requested to shutdown, it will automatically escalate and force shutdown.
is_stopped() Checks whether a client is stopped. Returns: true if the client is fully stopped.
on_attach(client, bufnr) Runs the on_attach function from the client's config if it was defined. Useful for buffer-local setup.
Members
{id} (number): The id allocated to the client.
{name} (string): If a name is specified on creation, that will be used. Otherwise it is just the client id. This is used for logs and messages.
{rpc} (table): RPC client object, for low level interaction with the client. See vim.lsp.rpc.start().
{offset_encoding} (string): The encoding used for communicating with the server. You can modify this in the config's on_init method before text is sent to the server.
{handlers} (table): The handlers used by the client as described in lsp-handler.
{requests} (table): The current pending requests in flight to the server. Entries are key-value pairs with the key being the request ID while the value is a table with type, bufnr, and method key-value pairs. type is either "pending" for an active request, or "cancel" for a cancel request.
{config} (table): copy of the table that was passed by the user to vim.lsp.start_client().
{server_capabilities} (table): Response from the server sent on initialize describing the server's capabilities.
client_is_stopped({client_id}) vim.lsp.client_is_stopped() Checks whether a client is stopped.
Parameters:
{client_id} (Number)
Return:
true if client is stopped, false otherwise.
vim.lsp.for_each_buffer_client() for_each_buffer_client({bufnr}, {fn}) Invokes a function for each LSP client attached to a buffer.
Parameters:
{bufnr} (number) Buffer number
{fn} (function) Function to run on each client attached to buffer {bufnr}. The function takes the client, client ID, and buffer number as arguments. Example:
vim.lsp.for_each_buffer_client(0, function(client, client_id, bufnr)
  print(vim.inspect(client))
end)
formatexpr({opts}) vim.lsp.formatexpr() Provides an interface between the built-in client and a formatexpr function.
Currently only supports a single client. This can be set viasetlocal formatexpr=v:lua.vim.lsp.formatexpr()` but will typically or in on_attach viavim.api.nvim_buf_set_option(bufnr, 'formatexpr', 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`.
Parameters:
{opts} (table) options for customizing the formatting expression which takes the following optional keys:
timeout_ms (default 500ms). The timeout period for the formatting request.
get_active_clients({filter}) vim.lsp.get_active_clients() Get active clients.
Parameters:
{filter} (table|nil) A table with key-value pairs used to filter the returned clients. The available keys are:
id (number): Only return clients with the given id
bufnr (number): Only return clients attached to this buffer
name (string): Only return clients with the given name
Return:
(table) List of vim.lsp.client objects
vim.lsp.get_buffers_by_client_id() get_buffers_by_client_id({client_id}) Returns list of buffers attached to client_id.
Parameters:
{client_id} (number) client id
Return:
(list) of buffer ids
get_client_by_id({client_id}) vim.lsp.get_client_by_id() Gets a client by id, or nil if the id is invalid. The returned client may not yet be fully initialized.
Parameters:
{client_id} (number) client id
Return:
vim.lsp.client object, or nil
get_log_path() vim.lsp.get_log_path() Gets the path of the logfile used by the LSP client.
Return:
(String) Path to logfile.
omnifunc({findstart}, {base}) vim.lsp.omnifunc() Implements 'omnifunc' compatible LSP completion.
Parameters:
{findstart} 0 or 1, decides behavior
{base} If findstart=0, text to match against
Return:
(number) Decided by {findstart}:
findstart=0: column where the completion starts, or -2 or -3
findstart=1: list of matches (actually just calls complete())
set_log_level({level}) vim.lsp.set_log_level() Sets the global log level for LSP logging.
Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF"
Level numbers begin with "TRACE" at 0
Use lsp.log_levels for reverse lookup.
Parameters:
{level} [number|string] the case insensitive level name or number
start({config}, {opts}) vim.lsp.start() Create a new LSP client and start a language server or reuses an already running client if one is found matching name and root_dir. Attaches the current buffer to the client.
Example:
vim.lsp.start({
   name = 'my-server-name',
   cmd = {'name-of-language-server-executable'},
   root_dir = vim.fs.dirname(vim.fs.find({'pyproject.toml', 'setup.py'}, { upward = true })[1]),
})
See vim.lsp.start_client() for all available options. The most important are:
name arbitrary name for the LSP client. Should be unique per language server.
cmd command (in list form) used to start the language server. Must be absolute, or found on $PATH. Shell constructs like ~ are not expanded.
root_dir path to the project root. By default this is used to decide if an existing client should be re-used. The example above uses vim.fs.find() and vim.fs.dirname() to detect the root by traversing the file system upwards starting from the current directory until either a pyproject.toml or setup.py file is found.
workspace_folders 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.
Language servers use this information to discover metadata like the dependencies of your project and they tend to index the contents within the project folder.
To ensure a language server is only started for languages it can handle, make sure to call vim.lsp.start() within a FileType autocmd. Either use :au, nvim_create_autocmd() or put the call in a ftplugin/<filetype_name>.lua (See ftplugin-name)
Parameters:
{config} (table) Same configuration as documented in vim.lsp.start_client()
{opts} nil|table Optional keyword arguments:
reuse_client (fun(client: client, config: table): boolean) Predicate used to decide if a client should be re-used. Used on all running clients. The default implementation re-uses a client if name and root_dir matches.
bufnr (number) Buffer handle to attach to if starting or re-using a client (0 for current).
Return:
(number|nil) client_id
start_client({config}) vim.lsp.start_client() Starts and initializes a client with the given configuration.
Parameter cmd is required.
The following parameters describe fields in the {config} table.
Parameters:
{cmd} (table|string|fun(dispatchers: table):table) command string or list treated like jobstart(). The command must launch the language server process. cmd can also be a function that creates an RPC client. The function receives a dispatchers table and must return a table with the functions request, notify, is_closing and terminate See vim.lsp.rpc.request() and vim.lsp.rpc.notify() For TCP there is a built-in rpc client factory: vim.lsp.rpc.connect()
{cmd_cwd} (string, default=|getcwd()|) Directory to launch the cmd process. Not related to root_dir.
{cmd_env} (table) Environment flags to pass to the LSP on spawn. Can be specified using keys like a map or as a list with k=v pairs or both. Non-string values are coerced to string. Example:
{ "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; }
{detached} (boolean, default true) Daemonize the server process so that it runs in a separate process group from Nvim. Nvim will shutdown the process on exit, but if Nvim fails to exit cleanly this could leave behind orphaned server processes.
{workspace_folders} (table) List of workspace folders passed to the language server. For backwards compatibility rootUri and rootPath will be derived from the first workspace folder in this list. See workspaceFolders in the LSP spec.
{capabilities} Map overriding the default capabilities defined by vim.lsp.protocol.make_client_capabilities(), passed to the language server on initialization. Hint: use make_client_capabilities() and modify its result.
Note: To send an empty dictionary use {[vim.type_idx]=vim.types.dictionary}, else it will be encoded as an array.
{handlers} Map of language server method names to lsp-handler
{settings} Map with language server specific settings. These are returned to the language server if requested via workspace/configuration. Keys are case-sensitive.
{commands} (table) Table that maps string of clientside commands to user-defined functions. Commands passed to start_client take precedence over the global command registry. Each key must be a unique command name, and the value is a function which is called if any LSP action (code action, code lenses, ...) triggers the command.
{init_options} Values to pass in the initialization request as initializationOptions. See initialize in the LSP spec.
{name} (string, default=client-id) Name in log messages.
{get_language_id} function(bufnr, filetype) -> language ID as string. Defaults to the filetype.
{offset_encoding} (default="utf-16") One of "utf-8", "utf-16", or "utf-32" which is the encoding that the LSP server expects. Client does not verify this is correct.
{on_error} Callback with parameters (code, ...), invoked when the client operation throws an error. code is a number describing the error. Other arguments may be passed depending on the error kind. See vim.lsp.rpc.client_errors for possible errors. Use vim.lsp.rpc.client_errors[code] to get human-friendly name.
{before_init} Callback with parameters (initialize_params, config) invoked before the LSP "initialize" phase, where params contains the parameters being sent to the server and config is the config that was passed to vim.lsp.start_client(). You can use this to modify parameters before they are sent.
{on_init} Callback (client, initialize_result) invoked after LSP "initialize", where result is a table of capabilities and anything else the server may send. For example, clangd sends initialize_result.offsetEncoding if capabilities.offsetEncoding was sent to it. You can only modify the client.offset_encoding here before any notifications are sent. Most language servers expect to be sent client specified settings after initialization. Neovim does not make this assumption. A workspace/didChangeConfiguration notification should be sent to the server during on_init.
{on_exit} Callback (code, signal, client_id) invoked on client exit.
code: exit code of the process
signal: number describing the signal used to terminate (if any)
client_id: client handle
{on_attach} Callback (client, bufnr) invoked when client attaches to a buffer.
{trace} "off" | "messages" | "verbose" | nil passed directly to the language server in the initialize request. Invalid/empty values will default to "off"
{flags} A table with flags for the client. The current (experimental) flags are:
allow_incremental_sync (bool, default true): Allow using incremental sync for buffer edits
debounce_text_changes (number, default 150): Debounce didChange notifications to the server by the given number in milliseconds. No debounce occurs if nil
exit_timeout (number|boolean, default false): Milliseconds to wait for server to exit cleanly after sending the "shutdown" request before sending kill -15. If set to false, nvim exits immediately after sending the "shutdown" request to the server.
{root_dir} (string) Directory where the LSP server will base its workspaceFolders, rootUri, and rootPath on initialization.
Return:
Client id. vim.lsp.get_client_by_id() Note: client may not be fully initialized. Use on_init to do any actions once the client has been initialized.
stop_client({client_id}, {force}) vim.lsp.stop_client() Stops a client(s).
You can also use the stop() function on a vim.lsp.client object. To stop all clients:
vim.lsp.stop_client(vim.lsp.get_active_clients())
By default asks the server to shutdown, unless stop was requested already for this client, then force-shutdown is attempted.
Parameters:
{client_id} client id or vim.lsp.client object, or list thereof
{force} (boolean) (optional) shutdown forcefully
tagfunc({...}) vim.lsp.tagfunc() Provides an interface between the built-in client and 'tagfunc'.
When used with normal mode commands (e.g. CTRL-]) this will invoke the "textDocument/definition" LSP method to find the tag under the cursor. Otherwise, uses "workspace/symbol". If no results are returned from any LSP servers, falls back to using built-in tags.
Parameters:
{pattern} Pattern used to find a workspace symbol
{flags} See tag-function
Return:
A list of matching tags
with({handler}, {override_config}) vim.lsp.with() Function to manage overriding defaults for LSP handlers.
Parameters:
{handler} (function) See lsp-handler
{override_config} (table) Table containing the keys to override behavior of the {handler}

Lua module: vim.lsp.buf lsp-buf

vim.lsp.buf.add_workspace_folder() add_workspace_folder({workspace_folder}) Add the folder at path to the workspace folders. If {path} is not provided, the user will be prompted for a path using input().
clear_references() vim.lsp.buf.clear_references() Removes document highlights from current buffer.
code_action({options}) vim.lsp.buf.code_action() Selects a code action available at the current cursor position.
Parameters:
{options} (table|nil) Optional table which holds the following optional fields:
context: (table|nil) Corresponds to CodeActionContext of the LSP specification:
diagnostics (table|nil): LSP`Diagnostic[]` . Inferred from the current position if not provided.
only (table|nil): List of LSP CodeActionKinds used to filter the code actions. Most language servers support values like refactor or quickfix.
filter: (function|nil) Predicate taking an CodeAction and returning a boolean.
apply: (boolean|nil) When set to true, and there is just one remaining action (after filtering), the action is applied without user query.
range: (table|nil) Range for which code actions should be requested. If in visual mode this defaults to the active selection. Table must contain start and end keys with {row, col} tuples using mark-like indexing. See api-indexing
completion({context}) vim.lsp.buf.completion() Retrieves the completion items at the current cursor position. Can only be called in Insert mode.
Parameters:
{context} (context support not yet implemented) Additional information about the context in which a completion was triggered (how it was triggered, and by which trigger character, if applicable)
See also:
vim.lsp.protocol.constants.CompletionTriggerKind
declaration({options}) vim.lsp.buf.declaration() Jumps to the declaration of the symbol under the cursor. Note: Many servers do not implement this method. Generally, see vim.lsp.buf.definition() instead.
Parameters:
{options} (table|nil) additional options
reuse_win: (boolean) Jump to existing window if buffer is already open.
on_list: (function) handler for list results. See lsp-on-list-handler
definition({options}) vim.lsp.buf.definition() Jumps to the definition of the symbol under the cursor.
Parameters:
{options} (table|nil) additional options
reuse_win: (boolean) Jump to existing window if buffer is already open.
on_list: (function) handler for list results. See lsp-on-list-handler
document_highlight() vim.lsp.buf.document_highlight() Send request to the server to resolve document highlights for the current text document position. This request can be triggered by a key mapping or by events such as CursorHold, e.g.:
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()
Note: Usage of vim.lsp.buf.document_highlight() requires the following highlight groups to be defined or you won't be able to see the actual highlights. hl-LspReferenceText hl-LspReferenceRead hl-LspReferenceWrite
document_symbol({options}) vim.lsp.buf.document_symbol() Lists all symbols in the current buffer in the quickfix window.
Parameters:
{options} (table|nil) additional options
on_list: (function) handler for list results. See lsp-on-list-handler
execute_command({command_params}) vim.lsp.buf.execute_command() Executes an LSP server command.
Parameters:
{command_params} (table) A valid ExecuteCommandParams object
format({options}) vim.lsp.buf.format() Formats a buffer using the attached (and optionally filtered) language server clients.
Parameters:
{options} table|nil Optional table which holds the following optional fields:
formatting_options (table|nil): Can be used to specify FormattingOptions. Some unspecified options will be automatically derived from the current Neovim options. See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#formattingOptions
timeout_ms (integer|nil, default 1000): Time in milliseconds to block for formatting requests. No effect if async=true
bufnr (number|nil): Restrict formatting to the clients attached to the given buffer, defaults to the current buffer (0).
filter (function|nil): Predicate used to filter clients. Receives a client as argument and must return a boolean. Clients matching the predicate are included. Example: •
-- Never request typescript-language-server for formatting
vim.lsp.buf.format {
  filter = function(client) return client.name ~= "tsserver" end
}
async boolean|nil If true the method won't block. Defaults to false. Editing the buffer while formatting asynchronous can lead to unexpected changes.
id (number|nil): Restrict formatting to the client with ID (client.id) matching this field.
name (string|nil): Restrict formatting to the client with name (client.name) matching this field.
range (table|nil) Range to format. Table must contain start and end keys with {row, col} tuples using (1,0) indexing. Defaults to current selection in visual mode Defaults to nil in other modes, formatting the full buffer
hover() vim.lsp.buf.hover() Displays hover information about the symbol under the cursor in a floating window. Calling the function twice will jump into the floating window.
implementation({options}) vim.lsp.buf.implementation() Lists all the implementations for the symbol under the cursor in the quickfix window.
Parameters:
{options} (table|nil) additional options
on_list: (function) handler for list results. See lsp-on-list-handler
incoming_calls() vim.lsp.buf.incoming_calls() Lists all the call sites of the symbol under the cursor in the quickfix window. If the symbol can resolve to multiple items, the user can pick one in the inputlist().
list_workspace_folders() vim.lsp.buf.list_workspace_folders() List workspace folders.
outgoing_calls() vim.lsp.buf.outgoing_calls() Lists all the items that are called by the symbol under the cursor in the quickfix window. If the symbol can resolve to multiple items, the user can pick one in the inputlist().
references({context}, {options}) vim.lsp.buf.references() Lists all the references to the symbol under the cursor in the quickfix window.
Parameters:
{context} (table) Context for the request
{options} (table|nil) additional options
on_list: (function) handler for list results. See lsp-on-list-handler
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().
rename({new_name}, {options}) vim.lsp.buf.rename() Renames all references to the symbol under the cursor.
Parameters:
{new_name} (string|nil) If not provided, the user will be prompted for a new name using vim.ui.input().
{options} (table|nil) additional options
filter (function|nil): Predicate used to filter clients. Receives a client as argument and must return a boolean. Clients matching the predicate are included.
name (string|nil): Restrict clients used for rename to ones where client.name matches this field.
server_ready() vim.lsp.buf.server_ready() Checks whether the language servers attached to the current buffer are ready.
Return:
true if server responds.
signature_help() vim.lsp.buf.signature_help() Displays signature information about the symbol under the cursor in a floating window.
type_definition({options}) vim.lsp.buf.type_definition() Jumps to the definition of the type of the symbol under the cursor.
Parameters:
{options} (table|nil) additional options
reuse_win: (boolean) Jump to existing window if buffer is already open.
on_list: (function) handler for list results. See lsp-on-list-handler
workspace_symbol({query}, {options}) vim.lsp.buf.workspace_symbol() Lists all symbols in the current workspace in the quickfix window.
The list is filtered against {query}; if the argument is omitted from the call, the user is prompted to enter a string on the command line. An empty string means no filtering is done.
Parameters:
{query} (string, optional)
{options} (table|nil) additional options
on_list: (function) handler for list results. See lsp-on-list-handler

Lua module: vim.lsp.diagnostic lsp-diagnostic

get_namespace({client_id}) vim.lsp.diagnostic.get_namespace() Get the diagnostic namespace associated with an LSP client vim.diagnostic.
Parameters:
{client_id} (number) The id of the LSP client
vim.lsp.diagnostic.on_publish_diagnostics() on_publish_diagnostics({_}, {result}, {ctx}, {config}) lsp-handler for the method "textDocument/publishDiagnostics"
See vim.diagnostic.config() for configuration options. Handler-specific configuration can be set using vim.lsp.with():
vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
  vim.lsp.diagnostic.on_publish_diagnostics, {
    -- Enable underline, use default values
    underline = true,
    -- Enable virtual text, override spacing to 4
    virtual_text = {
      spacing = 4,
    },
    -- Use a function to dynamically turn signs off
    -- and on, using buffer local variables
    signs = function(namespace, bufnr)
      return vim.b[bufnr].show_signs == true
    end,
    -- Disable a feature
    update_in_insert = false,
  }
)
Parameters:
{config} (table) Configuration table (see vim.diagnostic.config()).

Lua module: vim.lsp.codelens lsp-codelens

display({lenses}, {bufnr}, {client_id}) vim.lsp.codelens.display() Display the lenses using virtual text
Parameters:
{lenses} (table) of lenses to display (CodeLens[] | null)
{bufnr} (number)
{client_id} (number)
get({bufnr}) vim.lsp.codelens.get() Return all lenses for the given buffer
Parameters:
{bufnr} (number) Buffer number. 0 can be used for the current buffer.
Return:
(table) (CodeLens[])
vim.lsp.codelens.on_codelens() on_codelens({err}, {result}, {ctx}, {_}) lsp-handler for the method textDocument/codeLens
refresh() vim.lsp.codelens.refresh() Refresh the codelens for the current buffer
It is recommended to trigger this using an autocmd or via keymap.
autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
run() vim.lsp.codelens.run() Run the code lens in the current line
save({lenses}, {bufnr}, {client_id}) vim.lsp.codelens.save() Store lenses for a specific buffer and client
Parameters:
{lenses} (table) of lenses to store (CodeLens[] | null)
{bufnr} (number)
{client_id} (number)

Lua module: vim.lsp.handlers lsp-handlers

hover({_}, {result}, {ctx}, {config}) vim.lsp.handlers.hover() lsp-handler for the method "textDocument/hover"
vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
  vim.lsp.handlers.hover, {
    -- Use a sharp border with `FloatBorder` highlights
    border = "single",
    -- add the title in hover float window
    title = "hover"
  }
)
Parameters:
{config} (table) Configuration table.
border: (default=nil)
Add borders to the floating window
vim.lsp.handlers.signature_help() signature_help({_}, {result}, {ctx}, {config}) lsp-handler for the method "textDocument/signatureHelp". The active parameter is highlighted with hl-LspSignatureActiveParameter.
vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
  vim.lsp.handlers.signature_help, {
    -- Use a sharp border with `FloatBorder` highlights
    border = "single"
  }
)
Parameters:
{config} (table) Configuration table.
border: (default=nil)
Add borders to the floating window

Lua module: vim.lsp.util lsp-util

vim.lsp.util.apply_text_document_edit() apply_text_document_edit({text_document_edit}, {index}, {offset_encoding}) Applies a TextDocumentEdit, which is a list of changes to a single document.
Parameters:
{text_document_edit} (table) a TextDocumentEdit object
{index} (number) Optional index of the edit, if from a list of edits (or nil, if not from a list)
vim.lsp.util.apply_text_edits() apply_text_edits({text_edits}, {bufnr}, {offset_encoding}) Applies a list of text edits to a buffer.
Parameters:
{text_edits} (table) list of TextEdit objects
{bufnr} (number) Buffer id
{offset_encoding} (string) utf-8|utf-16|utf-32
vim.lsp.util.apply_workspace_edit() apply_workspace_edit({workspace_edit}, {offset_encoding}) Applies a WorkspaceEdit.
Parameters:
{workspace_edit} (table) WorkspaceEdit
{offset_encoding} (string) utf-8|utf-16|utf-32 (required)
buf_clear_references({bufnr}) vim.lsp.util.buf_clear_references() Removes document highlights from a buffer.
Parameters:
{bufnr} (number) Buffer id
vim.lsp.util.buf_highlight_references() buf_highlight_references({bufnr}, {references}, {offset_encoding}) Shows a list of document highlights for a certain buffer.
Parameters:
{bufnr} (number) Buffer id
{references} (table) List of 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.
Parameters:
{buf} (number) buffer number (0 for current)
{row} 0-indexed line
{col} 0-indexed byte offset in line
{offset_encoding} (string) utf-8|utf-16|utf-32|nil defaults to offset_encoding of first client of buf
Return:
(number, number) offset_encoding index of the character in line {row} column {col} in buffer {buf}
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.
Parameters:
{input} (MarkedString | MarkedString[] | MarkupContent)
{contents} (table, optional, default {}) List of strings to extend with converted lines
Return:
{contents}, extended with lines of converted markdown.
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.
Parameters:
{signature_help} Response of textDocument/SignatureHelp
{ft} optional filetype that will be use as the lang for the label markdown code block
{triggers} optional list of trigger characters from the lsp server. used to better determine parameter offsets
Return:
(list) of lines of converted markdown.
vim.lsp.util.extract_completion_items() extract_completion_items({result}) Can be used to extract the completion items from a textDocument/completion request, which may return one of CompletionItem[] , CompletionList or null.
Parameters:
{result} (table) The result of a textDocument/completion request
Return:
(table) List of completion items
get_effective_tabstop({bufnr}) vim.lsp.util.get_effective_tabstop() Returns indentation size.
Parameters:
{bufnr} (number|nil) Buffer handle, defaults to current
Return:
(number) indentation size
See also:
'shiftwidth'
vim.lsp.util.jump_to_location() jump_to_location({location}, {offset_encoding}, {reuse_win}) Jumps to a location.
Parameters:
{location} (table) (Location`LocationLink`)
{offset_encoding} "utf-8" | "utf-16" | "utf-32"
{reuse_win} (boolean) Jump to existing window if buffer is already open.
Return:
(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.
The result can be passed to the {list} argument of setqflist() or setloclist().
Parameters:
{locations} (table) list of Locations or LocationLinks
{offset_encoding} (string) offset_encoding for locations utf-8|utf-16|utf-32
Return:
(table) list of items
lookup_section({settings}, {section}) vim.lsp.util.lookup_section() Helper function to return nested values in language server settings
Parameters:
{settings} a table of language server settings
{section} a string indicating the field of the settings table
Return:
(table or string) The value of settings accessed via section
vim.lsp.util.make_floating_popup_options() make_floating_popup_options({width}, {height}, {opts}) Creates a table with sensible default options for a floating window. The table can be passed to nvim_open_win().
Parameters:
{width} (number) window width (in character cells)
{height} (number) window height (in character cells)
{opts} (table, optional)
offset_x (number) offset to add to col
offset_y (number) offset to add to row
border (string or table) override border
focusable (string or table) override focusable
zindex (string or table) override zindex, defaults to 50
Return:
(table) Options
vim.lsp.util.make_formatting_params() make_formatting_params({options}) Creates a DocumentFormattingParams object for the current buffer and cursor position.
Parameters:
{options} (table|nil) with valid FormattingOptions entries
Return:
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().
Parameters:
{start_pos} number[]|nil {row, col} mark-indexed position. Defaults to the start of the last visual selection.
{end_pos} number[]|nil {row, col} mark-indexed position. Defaults to the end of the last visual selection.
{bufnr} (number|nil) buffer handle or 0 for current, defaults to current
{offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults to offset_encoding of first client of bufnr
Return:
{ textDocument = { uri = current_file_uri }, range = { start = start_position, end = end_position } }
vim.lsp.util.make_position_params() make_position_params({window}, {offset_encoding}) Creates a TextDocumentPositionParams object for the current buffer and cursor position.
Parameters:
{window} (number|nil) window handle or 0 for current, defaults to current
{offset_encoding} (string) utf-8|utf-16|utf-32|nil defaults to offset_encoding of first client of buffer of window
Return:
TextDocumentPositionParams object
vim.lsp.util.make_range_params() make_range_params({window}, {offset_encoding}) Using the current position in the current buffer, creates an object that can be used as a building block for several LSP requests, such as textDocument/codeAction, textDocument/colorPresentation, textDocument/rangeFormatting.
Parameters:
{window} (number|nil) window handle or 0 for current, defaults to current
{offset_encoding} "utf-8"|"utf-16"|"utf-32"|nil defaults to offset_encoding of first client of buffer of window
Return:
{ textDocument = { uri = current_file_uri }, range = { start = current_position, end = current_position } }
vim.lsp.util.make_text_document_params() make_text_document_params({bufnr}) Creates a TextDocumentIdentifier object for the current buffer.
Parameters:
{bufnr} (number|nil) Buffer handle, defaults to current
Return:
TextDocumentIdentifier
vim.lsp.util.make_workspace_params() make_workspace_params({added}, {removed}) Create the workspace params
Parameters:
{added}
{removed}
vim.lsp.util.open_floating_preview() open_floating_preview({contents}, {syntax}, {opts}) Shows contents in a floating window.
Parameters:
{contents} (table) of lines to show in window
{syntax} (string) of syntax to set for opened buffer
{opts} (table) with optional fields (additional keys are passed on to nvim_open_win())
height: (number) height of floating window
width: (number) width of floating window
wrap: (boolean, default true) wrap long lines
wrap_at: (number) character to wrap at for computing height when wrap is enabled
max_width: (number) maximal width of floating window
max_height: (number) maximal height of floating window
pad_top: (number) number of lines to pad contents at top
pad_bottom: (number) number of lines to pad contents at bottom
focus_id: (string) if a popup with this id is opened, then focus it
close_events: (table) list of events that closes the floating window
focusable: (boolean, default true) Make float focusable
focus: (boolean, default true) If true, and if {focusable} is also true, focus an existing floating window with the same {focus_id}
Return:
bufnr,winnr buffer and window number of the newly created floating preview window
parse_snippet({input}) vim.lsp.util.parse_snippet() Parses snippets in a completion entry.
Parameters:
{input} (string) unparsed snippet
Return:
(string) parsed snippet
preview_location({location}, {opts}) vim.lsp.util.preview_location() Previews a location in a floating window
behavior depends on type of location:
for Location, range is shown (e.g., function definition)
for LocationLink, targetRange is shown (e.g., body of function definition)
Parameters:
{location} a single Location or LocationLink
Return:
(bufnr,winnr) buffer and window number of floating window or nil
rename({old_fname}, {new_fname}, {opts}) vim.lsp.util.rename() Rename old_fname to new_fname
Parameters:
{opts} (table)
set_lines({lines}, {A}, {B}, {new_lines}) vim.lsp.util.set_lines() Replaces text in a range with new text.
CAUTION: Changes in-place!
Parameters:
{lines} (table) Original list of strings
{A} (table) Start position; a 2-tuple of {line, col} numbers
{B} (table) End position; a 2-tuple of {line, col} numbers
{new_lines} A list of strings to replace the original
Return:
(table) The modified {lines} object
vim.lsp.util.show_document() show_document({location}, {offset_encoding}, {opts}) Shows document and optionally jumps to the location.
Parameters:
{location} (table) (Location`LocationLink`)
{offset_encoding} "utf-8" | "utf-16" | "utf-32"
{opts} (table) options
reuse_win (boolean) Jump to existing window if buffer is already open.
focus (boolean) Whether to focus/jump to location if possible. Defaults to true.
Return:
(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.
This method configures the given buffer and returns the lines to set.
If you want to open a popup with fancy markdown, use open_floating_preview instead
Parameters:
{contents} (table) of lines to show in window
{opts} dictionary with optional fields
height of floating window
width of floating window
wrap_at character to wrap at for computing height
max_width maximal width of floating window
max_height maximal height of floating window
pad_top number of lines to pad contents at top
pad_bottom number of lines to pad contents at bottom
separator insert separator after code block
Return:
width,height size of float
symbols_to_items({symbols}, {bufnr}) vim.lsp.util.symbols_to_items() Converts symbols to quickfix list items.
Parameters:
{symbols} DocumentSymbol[] or SymbolInformation[]
vim.lsp.util.text_document_completion_list_to_complete_items() text_document_completion_list_to_complete_items({result}, {prefix}) Turns the result of a textDocument/completion request into vim-compatible complete-items.
Parameters:
{result} The result of a textDocument/completion call, e.g. from vim.lsp.buf.completion(), which may be one of CompletionItem[], CompletionList or null
{prefix} (string) the prefix to filter the completion items
Return:
{ matches = complete-items table, incomplete = bool }
See also:
complete-items
trim_empty_lines({lines}) vim.lsp.util.trim_empty_lines() Removes empty lines from the beginning and end.
Parameters:
{lines} (table) list of lines to trim
Return:
(table) trimmed list of lines
vim.lsp.util.try_trim_markdown_code_blocks() try_trim_markdown_code_blocks({lines}) Accepts markdown lines and tries to reduce them to a filetype if they comprise just a single code block.
CAUTION: Modifies the input in-place!
Parameters:
{lines} (table) list of lines
Return:
(string) filetype or "markdown" if it was unchanged.

Lua module: vim.lsp.log lsp-log

get_filename() vim.lsp.log.get_filename() Returns the log filename.
Return:
(string) log filename
get_level() vim.lsp.log.get_level() Gets the current log level.
Return:
(string) current log level
set_format_func({handle}) vim.lsp.log.set_format_func() Sets formatting function used to format logs
Parameters:
{handle} (function) function to apply to logging arguments, pass vim.inspect for multi-line formatting
set_level({level}) vim.lsp.log.set_level() Sets the current log level.
Parameters:
{level} (string or number) One of vim.lsp.log.levels
should_log({level}) vim.lsp.log.should_log() Checks whether the level is sufficient for logging.
Parameters:
{level} (number) log level
Return:
(bool) true if would log, false if not

Lua module: vim.lsp.rpc lsp-rpc

connect({host}, {port}) vim.lsp.rpc.connect() Create a LSP RPC client factory that connects via TCP to the given host and port
Parameters:
{host} (string)
{port} (number)
Return:
(function)
format_rpc_error({err}) vim.lsp.rpc.format_rpc_error() Constructs an error message from an LSP error object.
Parameters:
{err} (table) The error object
Return:
(string) The formatted error message
notify({method}, {params}) vim.lsp.rpc.notify() Sends a notification to the LSP server.
Parameters:
{method} (string) The invoked LSP method
{params} (table|nil) Parameters for the invoked LSP method
Return:
(bool) true if notification could be sent, false if not
vim.lsp.rpc.request() request({method}, {params}, {callback}, {notify_reply_callback}) Sends a request to the LSP server and runs {callback} upon response.
Parameters:
{method} (string) The invoked LSP method
{params} (table|nil) Parameters for the invoked LSP method
{callback} (function) Callback to invoke
{notify_reply_callback} (function|nil) Callback to invoke as soon as a request is no longer pending
Return:
(bool, number) (true, message_id) if request could be sent, false if not
vim.lsp.rpc.rpc_response_error() rpc_response_error({code}, {message}, {data}) Creates an RPC response object/table.
Parameters:
{code} (number) RPC error code defined in vim.lsp.protocol.ErrorCodes
{message} (string|nil) arbitrary message to send to server
{data} any|nil arbitrary data to send to server
vim.lsp.rpc.start() start({cmd}, {cmd_args}, {dispatchers}, {extra_spawn_params}) 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()
Parameters:
{cmd} (string) Command to start the LSP server.
{cmd_args} (table) List of additional string arguments to pass to {cmd}.
{dispatchers} (table|nil) Dispatchers for LSP message types. Valid dispatcher names are:
"notification"
"server_request"
"on_error"
"on_exit"
{extra_spawn_params} (table|nil) Additional context for the LSP server process. May contain:
{cwd} (string) Working directory for the LSP server process
{env} (table) Additional environment variables for LSP server process
Return:
Client RPC object. Methods:
is_closing() returns a boolean indicating if the RPC is closing.
terminate() terminates the RPC client.

Lua module: vim.lsp.sync lsp-sync

vim.lsp.sync.compute_diff() compute_diff({___MissingCloseParenHere___}) Returns the range table for the difference between prev and curr lines
Parameters:
{prev_lines} (table) list of lines
{curr_lines} (table) list of lines
{firstline} (number) line to begin search for first difference
{lastline} (number) line to begin search in old_lines for last difference
{new_lastline} (number) line to begin search in new_lines for last difference
{offset_encoding} (string) encoding requested by language server

Lua module: vim.lsp.protocol lsp-protocol

vim.lsp.protocol.make_client_capabilities() make_client_capabilities() Gets a new ClientCapabilities object describing the LSP client capabilities.
vim.lsp.protocol.resolve_capabilities() resolve_capabilities({server_capabilities}) Creates a normalized object describing LSP server capabilities.
Parameters:
{server_capabilities} (table) Table of capabilities supported by the server
Return:
(table) Normalized table of capabilities
Main
Commands index
Quick reference