Nvim documentation: lsp

main help file
*lsp.txt*   LSP

                            NVIM REFERENCE MANUAL

LSP client/framework                                     *lsp*

Nvim supports the Language Server Protocol (LSP), which means it acts as
a client to LSP servers and includes a Lua framework `vim.lsp` for building
enhanced LSP tools.

LSP facilitates features like go-to-definition, find-references, hover,
completion, rename, format, refactor, etc., using semantic whole-project
analysis (unlike |ctags|).

                                      Type |gO| to see the table of contents.


QUICKSTART                                              *lsp-quickstart*

Nvim provides a LSP client, but the servers are provided by third parties.
Follow these steps to get LSP features:

  1. Install the nvim-lsp plugin.  It provides common configuration for
     various servers so you can get started quickly.
  2. Install a language server.  Try ":LspInstall <tab>" or use your system
     package manager to install the relevant language server:
  3. Add `nvim_lsp.xx.setup{…}` to your vimrc, where "xx" is the name of the
     relevant config.  See the nvim-lsp README for details.

To check LSP clients attached to the current buffer: 

  :lua print(vim.inspect(vim.lsp.buf_get_clients()))

Inline diagnostics are enabled automatically, e.g. syntax errors will be
annotated in the buffer.  But you probably want to use other features like
go-to-definition, hover, etc.  Example config:

  nnoremap <silent> gd    <cmd>lua vim.lsp.buf.declaration()<CR>
  nnoremap <silent> <c-]> <cmd>lua vim.lsp.buf.definition()<CR>
  nnoremap <silent> K     <cmd>lua vim.lsp.buf.hover()<CR>
  nnoremap <silent> gD    <cmd>lua vim.lsp.buf.implementation()<CR>
  nnoremap <silent> <c-k> <cmd>lua vim.lsp.buf.signature_help()<CR>
  nnoremap <silent> 1gD   <cmd>lua vim.lsp.buf.type_definition()<CR>
  nnoremap <silent> gr    <cmd>lua vim.lsp.buf.references()<CR>
  nnoremap <silent> g0    <cmd>lua vim.lsp.buf.document_symbol()<CR>
  nnoremap <silent> gW    <cmd>lua vim.lsp.buf.workspace_symbol()<CR>

Nvim provides the |vim.lsp.omnifunc| 'omnifunc' handler which allows
|i_CTRL-X_CTRL-O| to consume LSP completion. Example config (note the use of
|v:lua| to call Lua from Vimscript):

  " Use LSP omni-completion in Python files.
  autocmd Filetype python setlocal omnifunc=v:lua.vim.lsp.omnifunc

If a function has a `*_sync` variant, it's primarily intended for being run
automatically on file save.  E.g. code formatting:

  " Auto-format *.rs files prior to saving them
  autocmd BufWritePre *.rs lua vim.lsp.buf.formatting_sync(nil, 1000)


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())

- Q: Why isn't completion working?
  A: In the buffer where you want to use LSP, check that 'omnifunc' is set to

  :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.


LSP API                                                 *lsp-api*

The `vim.lsp` Lua module is a framework for building LSP plugins.

  1. Start with |vim.lsp.start_client()| and |vim.lsp.buf_attach_client()|.
  2. Peek at the API:
     :lua print(vim.inspect(vim.lsp))
   3. See |lsp-extension-example| for a full example.

LSP core API is described at |lsp-core|.  Those are the core functions for
creating and managing clients.

The `vim.lsp.buf_…` functions perform operations for all LSP clients attached
to the given buffer. |lsp-buf|

LSP request/response handlers are implemented as Lua callbacks.
|lsp-callbacks| The `vim.lsp.callbacks` table defines default callbacks used
when creating a new client. Keys are LSP method names:

  :lua print(vim.inspect(vim.tbl_keys(vim.lsp.callbacks)))

These LSP requests/notifications are defined by default:


You can check these via `vim.tbl_keys(vim.lsp.callbacks)`.

These will be used preferentially in `vim.lsp.buf_…` methods for handling
requests. They will also be used when responding to server requests and

Use cases:
- Users can modify this to customize to their preferences.
- UI plugins can modify this by assigning to
  `vim.lsp.callbacks[method]` so as to provide more specialized
  handling, allowing you to leverage the UI capabilities available. UIs should
  try to be conscientious of any existing changes the user may have set
  already by checking for existing values.

Any callbacks passed directly to `request` methods on a server client will
have the highest precedence, followed by the `callbacks`.

You can override the default handlers,
- globally: by modifying the `vim.lsp.callbacks` table
- per-client: by passing the {callbacks} table parameter to

Each handler has this signature:

  function(err, method, params, client_id)

Callbacks are functions which are called in a variety of situations by the
client. Their signature is `function(err, method, params, client_id)` They can
be set by the {callbacks} parameter for |vim.lsp.start_client| or via the

Handlers are called for:
- Notifications from the server (`err` is always `nil`).
- Requests initiated by the server (`err` is always `nil`).
  The handler can respond by returning two values: `result, err`
  where `err` must be shaped like an RPC error:
    `{ code, message, data? }`
  You can use |vim.lsp.rpc_response_error()| to create this object.
- Handling requests initiated by the client if the request doesn't explicitly
  specify a callback (such as in |vim.lsp.buf_request|).

VIM.LSP.PROTOCOL                                              *vim.lsp.protocol*

Module `vim.lsp.protocol` defines constants dictated by the LSP specification,
and helper functions for creating protocol-related objects.

For example `vim.lsp.protocol.ErrorCodes` allows reverse lookup by number or

  vim.lsp.protocol.TextDocumentSyncKind.Full == 1
  vim.lsp.protocol.TextDocumentSyncKind[1] == "Full"


LSP HIGHLIGHT                                                    *lsp-highlight*

LspDiagnosticsError               used for "Error" diagnostic virtual text

LspDiagnosticsErrorSign           used for "Error" diagnostic signs in sign

LspDiagnosticsErrorFloating       used for "Error" diagnostic messages in the
                                  diagnostics float

LspDiagnosticsWarning             used for "Warning" diagnostic virtual text

LspDiagnosticsWarningSign         used for "Warning" diagnostic signs in sign

LspDiagnosticsWarningFloating     used for "Warning" diagnostic messages in the
                                  diagnostics float

LspDiagnosticsInformation         used for "Information" diagnostic virtual text

LspDiagnosticsInformationSign     used for "Information" signs in sign column

LspDiagnosticsInformationFloating used for "Information" diagnostic messages in
                                  the diagnostics float

LspDiagnosticsHint                used for "Hint" diagnostic virtual text

LspDiagnosticsHintSign            used for "Hint" diagnostic signs in sign

LspDiagnosticsHintFloating        used for "Hint" diagnostic messages in the
                                  diagnostics float

LspReferenceText          used for highlighting "text" references

LspReferenceRead          used for highlighting "read" references

LspReferenceWrite         used for highlighting "write" references


LSP EXAMPLE                                            *lsp-extension-example*

This example is for plugin authors or users who want a lot of control. If you
are just getting started see |lsp-quickstart|.

For more advanced configurations where just filtering by filetype isn't
sufficient, you can use the `vim.lsp.start_client()` and
`vim.lsp.buf_attach_client()` commands to easily customize the configuration
however you please. For example, if you want to do your own filtering, or
start a new LSP client based on the root directory for if you plan to work
with multiple projects in a single session. Below is a fully working Lua
example which can do exactly that.

The example will:
1. Check for each new buffer whether or not we want to start an LSP client.
2. Try to find a root directory by ascending from the buffer's path.
3. Create a new LSP for that root directory if one doesn't exist.
4. Attach the buffer to the client for that root directory.

  -- Some path manipulation utilities
  local function is_dir(filename)
    local stat = vim.loop.fs_stat(filename)
    return stat and stat.type == 'directory' or false

  local path_sep = vim.loop.os_uname().sysname == "Windows" and "\\" or "/"
  -- Asumes filepath is a file.
  local function dirname(filepath)
    local is_changed = false
    local result = filepath:gsub(path_sep.."([^"..path_sep.."]+)$", function()
      is_changed = true
      return ""
    return result, is_changed

  local function path_join(...)
    return table.concat(vim.tbl_flatten {...}, path_sep)

  -- Ascend the buffer's path until we find the rootdir.
  -- is_root_path is a function which returns bool
  local function buffer_find_root_dir(bufnr, is_root_path)
    local bufname = vim.api.nvim_buf_get_name(bufnr)
    if vim.fn.filereadable(bufname) == 0 then
      return nil
    local dir = bufname
    -- Just in case our algo is buggy, don't infinite loop.
    for _ = 1, 100 do
      local did_change
      dir, did_change = dirname(dir)
      if is_root_path(dir, bufname) then
        return dir, bufname
      -- If we can't ascend further, then stop looking.
      if not did_change then
        return nil

  -- A table to store our root_dir to client_id lookup. We want one LSP per
  -- root directory, and this is how we assert that.
  local javascript_lsps = {}
  -- Which filetypes we want to consider.
  local javascript_filetypes = {
    ["javascript.jsx"] = true;
    ["javascript"]     = true;
    ["typescript"]     = true;
    ["typescript.jsx"] = true;

  -- Create a template configuration for a server to start, minus the root_dir
  -- which we will specify later.
  local javascript_lsp_config = {
    name = "javascript";
    cmd = { path_join(os.getenv("JAVASCRIPT_LANGUAGE_SERVER_DIRECTORY"), "lib", "language-server-stdio.js") };

  -- This needs to be global so that we can call it from the autocmd.
  function check_start_javascript_lsp()
    local bufnr = vim.api.nvim_get_current_buf()
    -- Filter which files we are considering.
    if not javascript_filetypes[vim.api.nvim_buf_get_option(bufnr, 'filetype')] then
    -- Try to find our root directory. We will define this as a directory which contains
    -- node_modules. Another choice would be to check for `package.json`, or for `.git`.
    local root_dir = buffer_find_root_dir(bufnr, function(dir)
      return is_dir(path_join(dir, 'node_modules'))
      -- return vim.fn.filereadable(path_join(dir, 'package.json')) == 1
      -- return is_dir(path_join(dir, '.git'))
    -- We couldn't find a root directory, so ignore this file.
    if not root_dir then return end

    -- Check if we have a client alredy or start and store it.
    local client_id = javascript_lsps[root_dir]
    if not client_id then
      local new_config = vim.tbl_extend("error", javascript_lsp_config, {
        root_dir = root_dir;
      client_id = vim.lsp.start_client(new_config)
      javascript_lsps[root_dir] = client_id
    -- Finally, attach to the buffer to track changes. This will do nothing if we
    -- are already attached.
    vim.lsp.buf_attach_client(bufnr, client_id)

  vim.api.nvim_command [[autocmd BufReadPost * lua check_start_javascript_lsp()]]


AUTOCOMMANDS                                                *lsp-autocommands*

LspDiagnosticsChanged           After receiving publishDiagnostics server response


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.

                    {bufnr}      (number) Buffer handle, or 0 for current
                    {client_id}  (number) Client id

buf_get_clients({bufnr})                           *vim.lsp.buf_get_clients()*
                Gets a map of client_id:client pairs for the given buffer,
                where each value is a |vim.lsp.client| object.

                    {bufnr}  (optional, number): Buffer handle, or 0 for

buf_get_full_text({bufnr})                       *vim.lsp.buf_get_full_text()*
                TODO: Documentation

buf_is_attached({bufnr}, {client_id})              *vim.lsp.buf_is_attached()*
                Checks if a buffer is attached for a particular client.

                    {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

                    {bufnr}   [number] (optional): The number of the buffer
                    {method}  [string]: Name of the request method
                    {params}  [string]: Arguments to send to the server

                    true if any client returns true; false otherwise

buf_request({bufnr}, {method}, {params}, {callback})
                Sends an async request for all active clients attached to the

                    {bufnr}     (number) Buffer handle, or 0 for current.
                    {method}    (string) LSP method name
                    {params}    (optional, table) Parameters to send to the
                    {callback}  (optional, functionnil) Handler

                    • Map of client-id:request-id pairs for all successful
                    • Function which can be used to cancel all the requests.
                      You could instead iterate all clients and call their
                      `cancel_request()` methods.

buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})
                Sends a request to a server and waits for the response.

                Calls |vim.lsp.buf_request()| but blocks Nvim while awaiting
                the result. Parameters are the same as |vim.lsp.buf_request()|
                but the return result is different. Wait maximum of
                {timeout_ms} (default 100) ms.

                    {bufnr}       (number) Buffer handle, or 0 for current.
                    {method}      (string) LSP method name
                    {params}      (optional, table) Parameters to send to the
                    {timeout_ms}  (optional, number, default=100) Maximum time
                                  in milliseconds to wait for a result.

                    Map of client_id:request_result. On timeout, cancel or
                    error, returns `(nil, err)` where `err` is a string
                    describing the failure reason.

cancel_request({id})                                *vim.lsp.cancel_request()*
                TODO: Documentation

client()                                                      *vim.lsp.client*
                LSP client object.

                • Methods:
                  • request(method, params, [callback]) Send a request to the
                    server. If callback is not specified, it will use
                    {client.callbacks} to try to find a callback. If one is
                    not found there, then an error will occur. This is a thin
                    wrapper around {client.rpc.request} with some additional
                    checking. Returns a boolean to indicate if the
                    notification was successful. If it is false, then it will
                    always be false (the client has shutdown). If it was
                    successful, then it will return the request id as the
                    second result. You can use this with `notify("$/cancel", {
                    id = request_id })` to cancel the request. This helper is
                    made automatically with |vim.lsp.buf_request()| Returns:
                    status, [client_id]
                  • notify(method, params) This is just {client.rpc.notify}()
                    Returns a boolean to indicate if the notification was
                    successful. If it is false, then it will always be false
                    (the client has shutdown). Returns: status
                  • cancel_request(id) This is just
                    {client.rpc.notify}("$/cancelRequest", { id = id })
                    Returns the same as `notify()` .
                  • stop([force]) Stop a client, optionally with force. By
                    default, it will just ask the server to shutdown without
                    force. If you request to stop a client which has
                    previously been requested to shutdown, it will
                    automatically escalate and force shutdown.
                  • is_stopped() Returns true if the client is fully stopped.

                • Members
                  • id (number): The id allocated to the client.
                  • name (string): If a name is specified on creation, that
                    will be used. Otherwise it is just the client id. This is
                    used for logs and messages.
                  • offset_encoding (string): The encoding used for
                    communicating with the server. You can modify this in the
                    `on_init` method before text is sent to the server.
                  • callbacks (table): The callbacks used by the client as
                    described in |lsp-callbacks|.
                  • config (table): copy of the table that was passed by the
                    user to |vim.lsp.start_client()|.
                  • server_capabilities (table): Response from the server sent
                    on `initialize` describing the server's capabilities.
                  • resolved_capabilities (table): Normalized table of
                    capabilities that we have detected based on the initialize
                    response from the server in `server_capabilities` .

client_is_stopped({client_id})                   *vim.lsp.client_is_stopped()*
                TODO: Documentation

define_default_sign({name}, {properties})
                TODO: Documentation

err_message({...})                                     *vim.lsp.err_message()*
                TODO: Documentation

for_each_buffer_client({bufnr}, {callback})
                TODO: Documentation

get_active_clients()                            *vim.lsp.get_active_clients()*
                Gets all active clients.

                    Table of |vim.lsp.client| objects

get_client_by_id({client_id})                     *vim.lsp.get_client_by_id()*
                Gets an active client by id, or nil if the id is invalid or
                the client is not yet initialized.

                    {client_id}  client id number

                    |vim.lsp.client| object, or nil

get_log_path()                                        *vim.lsp.get_log_path()*
                TODO: Documentation

initialize()                                            *vim.lsp.initialize()*
                TODO: Documentation

is_dir({filename})                                          *vim.lsp.is_dir()*
                TODO: Documentation

is_stopped()                                            *vim.lsp.is_stopped()*
                TODO: Documentation

next_client_id()                                    *vim.lsp.next_client_id()*
                TODO: Documentation

notification({method}, {params})                      *vim.lsp.notification()*
                TODO: Documentation

notify({...})                                               *vim.lsp.notify()*
                TODO: Documentation

omnifunc({findstart}, {base})                             *vim.lsp.omnifunc()*
                Implements 'omnifunc' compatible LSP completion.

                    {findstart}  0 or 1, decides behavior
                    {base}       If findstart=0, text to match against

                    (number) Decided by`findstart`:
                    • findstart=0: column where the completion starts, or -2
                      or -3
                    • findstart=1: list of matches (actually just calls

                See also: 

on_error({code}, {err})                                   *vim.lsp.on_error()*
                TODO: Documentation

on_exit({code}, {signal})                                  *vim.lsp.on_exit()*
                TODO: Documentation

once({fn})                                                    *vim.lsp.once()*
                TODO: Documentation

optional_validator({fn})                        *vim.lsp.optional_validator()*
                TODO: Documentation

request({method}, {params}, {callback}, {bufnr})           *vim.lsp.request()*
                TODO: Documentation

resolve_bufnr({bufnr})                               *vim.lsp.resolve_bufnr()*
                TODO: Documentation

resolve_callback({method})                        *vim.lsp.resolve_callback()*
                TODO: Documentation

server_request({method}, {params})                  *vim.lsp.server_request()*
                TODO: Documentation

set_log_level({level})                               *vim.lsp.set_log_level()*
                Sets the global log level for LSP logging.

                Levels by name: "trace", "debug", "info", "warn", "error"
                Level numbers begin with "trace" at 0

                Use `lsp.log_levels` for reverse lookup.

                    {level}  [number|string] the case insensitive level name
                             or number

                See also: 

start_client({config})                                *vim.lsp.start_client()*
                Starts and initializes a client with the given configuration.

                Parameters `cmd` and `root_dir` are required.

                    {root_dir}         (required, string) Directory where the
                                       LSP server will base its rootUri on
                    {cmd}              (required, string or list treated like
                                       |jobstart()|) Base command that
                                       initiates the LSP client.
                    {cmd_cwd}          (string, default=|getcwd()|) Directory
                                       to launch the `cmd` process. Not
                                       related to `root_dir` .
                    {cmd_env}          (table) Environment flags to pass to
                                       the LSP on spawn. Can be specified
                                       using keys like a map or as a list with `k=v` pairs or both. Non-string values are
                                       coerced to string. Example:

                 { "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = ""; }
                    {capabilities}     Map overriding the default capabilities
                                       defined by
                                       passed to the language server on
                                       initialization. Hint: use
                                       make_client_capabilities() and modify
                                       its result.
                                       • Note: To send an empty dictionary use
                                         , else it will be encoded as an
                    {callbacks}        Map of language server method names to `function(err, method, params,
                                       client_id)` handler. Invoked for:
                                       • Notifications from the server, where
                                         `err` will always be `nil` .
                                       • Requests initiated by the server. For
                                         these you can respond by returning
                                         two values: `result, err` where err
                                         must be shaped like a RPC error, i.e.
                                         `{ code, message, data? }` . Use
                                         |vim.lsp.rpc_response_error()| to
                                         help with this.
                                       • Default callback for client requests
                                         not explicitly specifying a callback.
                    {init_options}     Values to pass in the initialization
                                       request as `initializationOptions` .
                                       See `initialize` in the LSP spec.
                    {name}             (string, default=client-id) Name in log
                    {offset_encoding}  (default="utf-16") One of "utf-8",
                                       "utf-16", or "utf-32" which is the
                                       encoding that the LSP server expects.
                                       Client does not verify this is correct.
                    {on_error}         Callback with parameters (code, ...),
                                       invoked when the client operation
                                       throws an error. `code` is a number
                                       describing the error. Other arguments
                                       may be passed depending on the error
                                       kind. See |vim.lsp.client_errors| for
                                       possible errors. Use
                                       `vim.lsp.client_errors[code]` to get
                                       human-friendly name.
                    {before_init}      Callback with parameters
                                       (initialize_params, config) invoked
                                       before the LSP "initialize" phase,
                                       where `params` contains the parameters
                                       being sent to the server and `config`
                                       is the config that was passed to
                                       `start_client()` . You can use this to
                                       modify parameters before they are sent.
                    {on_init}          Callback (client, initialize_result)
                                       invoked after LSP "initialize", where
                                       `result` is a table of `capabilities`
                                       and anything else the server may send.
                                       For example, clangd sends
                                       `initialize_result.offsetEncoding` if
                                       `capabilities.offsetEncoding` was sent
                                       to it. You can only modify the
                                       `client.offset_encoding` here before
                                       any notifications are sent.
                    {on_exit}          Callback (code, signal, client_id)
                                       invoked on client exit.
                                       • code: exit code of the process
                                       • signal: number describing the signal
                                         used to terminate (if any)
                                       • client_id: client handle
                    {on_attach}        Callback (client, bufnr) invoked when
                                       client attaches to a buffer.
                    {trace}            "off" | "messages" | "verbose" | nil
                                       passed directly to the language server
                                       in the initialize request.
                                       Invalid/empty values will default to

                    Client id. |vim.lsp.get_client_by_id()| Note: client is
                    only available after it has been initialized, which may
                    happen after a small delay (or never if there is an
                    error). Use `on_init` to do any actions once the client
                    has been initialized.

stop({force})                                                 *vim.lsp.stop()*
                TODO: Documentation

stop_client({client_id}, {force})                      *vim.lsp.stop_client()*
                Stops a client(s).

                You can also use the `stop()` function on a |vim.lsp.client|
                object. To stop all clients:


                By default asks the server to shutdown, unless stop was
                requested already for this client, then force-shutdown is

                    {client_id}  client id or |vim.lsp.client| object, or list
                    {force}      boolean (optional) shutdown forcefully

text_document_did_open_handler({bufnr}, {client})
                TODO: Documentation

unsupported_method({method})                    *vim.lsp.unsupported_method()*
                TODO: Documentation

validate_client_config({config})            *vim.lsp.validate_client_config()*
                TODO: Documentation

validate_encoding({encoding})                    *vim.lsp.validate_encoding()*
                TODO: Documentation


Lua module: vim.lsp.protocol                                    *lsp-protocol*

ifnil({a}, {b})                                     *vim.lsp.protocol.ifnil()*
                TODO: Documentation

                Gets a new ClientCapabilities object describing the LSP client

                `*` to match one or more characters in a path segment `?` to
                match on one character in a path segment `**` to match any
                number of path segments, including none `{}` to group
                conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and
                JavaScript files) `[]` to declare a range of characters to
                match in a path segment (e.g., `example.[0-9]` to match on
                `example.0` , `example.1` , …) `[!...]` to negate a range of
                characters to match in a path segment (e.g., `example.[!0-9]`
                to match on `example.a` , `example.b` , but not `example.0` )

                TODO: Documentation

                TODO: Documentation


Lua module: vim.lsp.buf                                              *lsp-buf*

clear_references()                            *vim.lsp.buf.clear_references()*
                TODO: Documentation

code_action({context})                             *vim.lsp.buf.code_action()*
                TODO: Documentation

completion({context})                               *vim.lsp.buf.completion()*
                Retrieves the completion items at the current cursor position.
                Can only be called in Insert mode.

declaration()                                      *vim.lsp.buf.declaration()*
                Jumps to the declaration of the symbol under the cursor.

definition()                                        *vim.lsp.buf.definition()*
                Jumps to the definition of the symbol under the cursor.

document_highlight()                        *vim.lsp.buf.document_highlight()*
                Send request to server to resolve document highlights for the
                current text document position. This request can be associated
                to key mapping or to events such as `CursorHold` , eg:

    vim.api.nvim_command [[autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()]]
    vim.api.nvim_command [[autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()]]
    vim.api.nvim_command [[autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()]]

document_symbol()                              *vim.lsp.buf.document_symbol()*
                Lists all symbols in the current buffer in the quickfix

execute_command({command})                     *vim.lsp.buf.execute_command()*
                TODO: Documentation

formatting({options})                               *vim.lsp.buf.formatting()*
                Formats the current buffer.

                The optional {options} table can be used to specify
                FormattingOptions, a list of which is available at https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting . Some unspecified options will be automatically derived from
                the current Neovim options.

formatting_sync({options}, {timeout_ms})
                Perform |vim.lsp.buf.formatting()| synchronously.

                Useful for running on save, to make sure buffer is formatted
                prior to being saved. {timeout_ms} is passed on to

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()                                *vim.lsp.buf.implementation()*
                Lists all the implementations for the symbol under the cursor
                in the quickfix window.

npcall({fn}, {...})                                     *vim.lsp.buf.npcall()*
                TODO: Documentation

ok_or_nil({status}, {...})                           *vim.lsp.buf.ok_or_nil()*
                TODO: Documentation

range_formatting({options}, {start_pos}, {end_pos})
                TODO: Documentation

references({context})                               *vim.lsp.buf.references()*
                Lists all the references to the symbol under the cursor in the
                quickfix window.

rename({new_name})                                      *vim.lsp.buf.rename()*
                Renames all references to the symbol under the cursor. If
                {new_name} is not provided, the user will be prompted for a
                new name using |input()|.

request({method}, {params}, {callback})                *vim.lsp.buf.request()*
                TODO: Documentation

server_ready()                                    *vim.lsp.buf.server_ready()*
                    `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()                              *vim.lsp.buf.type_definition()*
                Jumps to the definition of the type of the symbol under the

workspace_symbol({query})                     *vim.lsp.buf.workspace_symbol()*
                Lists all symbols in the current workspace in the quickfix

                The list is filtered against the optional argument {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.

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|.

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|.


Lua module: vim.lsp.callbacks                                  *lsp-callbacks*

err_message({...})                           *vim.lsp.callbacks.err_message()*
                TODO: Documentation

location_callback({_}, {method}, {result})
                TODO: Documentation


Lua module: vim.lsp.log                                              *lsp-log*

get_filename()                                    *vim.lsp.log.get_filename()*
                TODO: Documentation

path_join({...})                                     *vim.lsp.log.path_join()*
                TODO: Documentation

set_level({level})                                   *vim.lsp.log.set_level()*
                TODO: Documentation

should_log({level})                                 *vim.lsp.log.should_log()*
                TODO: Documentation


Lua module: vim.lsp.rpc                                              *lsp-rpc*

convert_NIL({v})                                   *vim.lsp.rpc.convert_NIL()*
                TODO: Documentation

create_and_start_client({cmd}, {cmd_args}, {handlers},
                TODO: Documentation

encode_and_send({payload})                     *vim.lsp.rpc.encode_and_send()*
                TODO: Documentation

env_merge({env})                                     *vim.lsp.rpc.env_merge()*
                Merges current process env with the given env and returns the
                result as a list of "k=v" strings.


                > in:    { PRODUCTION="false", PATH="/usr/bin/", PORT=123, HOST="", }
                 out:   { "PRODUCTION=false", "PATH=/usr/bin/", "PORT=123", "HOST=", }

                TODO: Documentation

format_rpc_error({err})                       *vim.lsp.rpc.format_rpc_error()*
                TODO: Documentation

handle_body({body})                                *vim.lsp.rpc.handle_body()*
                TODO: Documentation

is_dir({filename})                                      *vim.lsp.rpc.is_dir()*
                TODO: Documentation

json_decode({data})                                *vim.lsp.rpc.json_decode()*
                TODO: Documentation

json_encode({data})                                *vim.lsp.rpc.json_encode()*
                TODO: Documentation

notification({method}, {params})                  *vim.lsp.rpc.notification()*
                TODO: Documentation

on_error({errkind}, {...})                            *vim.lsp.rpc.on_error()*
                TODO: Documentation

on_exit({code}, {signal})                              *vim.lsp.rpc.on_exit()*
                TODO: Documentation

onexit({code}, {signal})                                *vim.lsp.rpc.onexit()*
                TODO: Documentation

parse_headers({header})                          *vim.lsp.rpc.parse_headers()*
                TODO: Documentation

pcall_handler({errkind}, {status}, {head}, {...})
                TODO: Documentation

request_parser_loop()                      *vim.lsp.rpc.request_parser_loop()*
                TODO: Documentation

rpc_response_error({code}, {message}, {data})
                Creates an RPC response object/table.

                    {code}     RPC error code defined in
                    {message}  (optional) arbitrary message to send to server
                    {data}     (optional) arbitrary data to send to server

send_notification({method}, {params})        *vim.lsp.rpc.send_notification()*
                TODO: Documentation

send_request({method}, {params}, {callback})
                TODO: Documentation

send_response({request_id}, {err}, {result})
                TODO: Documentation

server_request({method}, {params})              *vim.lsp.rpc.server_request()*
                TODO: Documentation

try_call({errkind}, {fn}, {...})                      *vim.lsp.rpc.try_call()*
                TODO: Documentation


Lua module: vim.lsp.util                                            *lsp-util*

apply_syntax_to_region({ft}, {start}, {finish})
                TODO: Documentation

                TODO: Documentation

apply_text_edits({text_edits}, {bufnr})
                TODO: Documentation

                TODO: Documentation

buf_clear_diagnostics({bufnr})          *vim.lsp.util.buf_clear_diagnostics()*
                TODO: Documentation

buf_clear_references({bufnr})            *vim.lsp.util.buf_clear_references()*
                TODO: Documentation

buf_diagnostics_count({kind})           *vim.lsp.util.buf_diagnostics_count()*
                Returns the number of diagnostics of given kind for current

                Useful for showing diagnostic counts in statusline. eg:

    function! LspStatus() abort
        let sl = ''
        if luaeval('not vim.tbl_isempty(vim.lsp.buf_get_clients(0))')
            let sl.='%#MyStatuslineLSP#E:'
            let sl.='%#MyStatuslineLSPErrors#%{luaeval("vim.lsp.util.buf_diagnostics_count([[Error]])")}'
            let sl.='%#MyStatuslineLSP# W:'
            let sl.='%#MyStatuslineLSPWarnings#%{luaeval("vim.lsp.util.buf_diagnostics_count([[Warning]])")}'
            let sl.='%#MyStatuslineLSPErrors#off'
        return sl
    let &l:statusline = '%#MyStatuslineLSP#LSP '.LspStatus()

                    {kind}  Diagnostic severity kind: See

                    Count of diagnostics

buf_diagnostics_save_positions({bufnr}, {diagnostics})
                Saves the diagnostics (Diagnostic[]) into diagnostics_by_buf

                    {bufnr}        bufnr for which the diagnostics are for.
                    {diagnostics}  Diagnostics[] received from the language

buf_diagnostics_signs({bufnr}, {diagnostics})
                Place signs for each diagnostic in the sign column.

                Sign characters can be customized with the following commands:

    sign define LspDiagnosticsErrorSign text=E texthl=LspDiagnosticsError linehl= numhl=
    sign define LspDiagnosticsWarningSign text=W texthl=LspDiagnosticsWarning linehl= numhl=
    sign define LspDiagnosticsInformationSign text=I texthl=LspDiagnosticsInformation linehl= numhl=
    sign define LspDiagnosticsHintSign text=H texthl=LspDiagnosticsHint linehl= numhl=

buf_diagnostics_underline({bufnr}, {diagnostics})
                TODO: Documentation

buf_diagnostics_virtual_text({bufnr}, {diagnostics})
                TODO: Documentation

buf_highlight_references({bufnr}, {references})
                TODO: Documentation

character_offset({buf}, {row}, {col})        *vim.lsp.util.character_offset()*
                TODO: Documentation

close_preview_autocmd({events}, {winnr})
                TODO: Documentation

convert_input_to_markdown_lines({input}, {contents})
                TODO: Documentation

                TODO: Documentation

                TODO: Documentation

                TODO: Documentation

fancy_floating_markdown({contents}, {opts})
                Convert 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. The result is shown
                in a floating preview TODO: refactor to separate
                stripping/converting and make use of open_floating_preview

                    {contents}  table of lines to show in window
                    {opts}      dictionary with optional fields

                    width,height size of float

find_window_by_var({name}, {value})        *vim.lsp.util.find_window_by_var()*
                TODO: Documentation

focusable_float({unique_name}, {fn})          *vim.lsp.util.focusable_float()*
                TODO: Documentation

focusable_preview({unique_name}, {fn})
                TODO: Documentation

get_completion_word({item})               *vim.lsp.util.get_completion_word()*
                TODO: Documentation

                TODO: Documentation

get_effective_tabstop({bufnr})          *vim.lsp.util.get_effective_tabstop()*
                Get visual width of tabstop.

                    {bufnr}  (optional, number): Buffer handle, defaults to

                    (number) tabstop visual width

                See also: 

get_line_byte_from_position({bufnr}, {position})
                TODO: Documentation

get_line_diagnostics()                   *vim.lsp.util.get_line_diagnostics()*
                TODO: Documentation

                TODO: Documentation

jump_to_location({location})                 *vim.lsp.util.jump_to_location()*
                TODO: Documentation

locations_to_items({locations})            *vim.lsp.util.locations_to_items()*
                TODO: Documentation

make_floating_popup_options({width}, {height}, {opts})
                TODO: Documentation

                TODO: Documentation

make_position_param()                     *vim.lsp.util.make_position_param()*
                TODO: Documentation

make_position_params()                   *vim.lsp.util.make_position_params()*
                TODO: Documentation

make_range_params()                         *vim.lsp.util.make_range_params()*
                TODO: Documentation

make_text_document_params()         *vim.lsp.util.make_text_document_params()*
                TODO: Documentation

npcall({fn}, {...})                                    *vim.lsp.util.npcall()*
                TODO: Documentation

ok_or_nil({status}, {...})                          *vim.lsp.util.ok_or_nil()*
                TODO: Documentation

open_floating_preview({contents}, {filetype}, {opts})
                Show contents in a floating window

                    {contents}  table of lines to show in window
                    {filetype}  string of filetype to set for opened buffer
                    {opts}      dictionary with optional fields

                    bufnr,winnr buffer and window number of floating window or

parse_snippet({input})                          *vim.lsp.util.parse_snippet()*
                TODO: Documentation

parse_snippet_rec({input}, {inner})         *vim.lsp.util.parse_snippet_rec()*
                TODO: Documentation

preview_location({location})                 *vim.lsp.util.preview_location()*
                Preview a location in a floating windows

                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)

                    {location}  a single Location or LocationLink

                    bufnr,winnr buffer and window number of floating window or

remove_unmatch_completion_items({items}, {prefix})
                TODO: Documentation

set_lines({lines}, {A}, {B}, {new_lines})           *vim.lsp.util.set_lines()*
                TODO: Documentation

set_loclist({items})                              *vim.lsp.util.set_loclist()*
                TODO: Documentation

set_qflist({items})                                *vim.lsp.util.set_qflist()*
                TODO: Documentation

show_line_diagnostics()                 *vim.lsp.util.show_line_diagnostics()*
                TODO: Documentation

sort_by_key({fn})                                 *vim.lsp.util.sort_by_key()*
                TODO: Documentation

sort_completion_items({items})          *vim.lsp.util.sort_completion_items()*
                TODO: Documentation

split_lines({value})                              *vim.lsp.util.split_lines()*
                TODO: Documentation

symbols_to_items({symbols}, {bufnr})         *vim.lsp.util.symbols_to_items()*
                Convert symbols to quickfix list items

                    {symbols}  DocumentSymbol[] or SymbolInformation[]

text_document_completion_list_to_complete_items({result}, {prefix})
                TODO: Documentation

trim_empty_lines({lines})                    *vim.lsp.util.trim_empty_lines()*
                TODO: Documentation

                TODO: Documentation

top - main help file