Quick links: help overview · quick reference · user manual toc · reference manual toc
Go to keyword (shortcut: k)
Site search (shortcut: s)
lsp.txt   LSP


                            NVIM REFERENCE MANUAL


LSP client/framework                                     lsp LSP

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

    https://microsoft.github.io/language-server-protocol/

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

                                      Type gO to see the table of contents.

==============================================================================
QUICKSTART                                              lsp-quickstart

Nvim provides 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. You can find language servers here:
   https://microsoft.github.io/language-server-protocol/implementors/servers/

2. Configure the LSP client per language server. See vim.lsp.start() or use
   this minimal example as a guide: 

    vim.lsp.start({
      name = 'my-server-name',
      cmd = {'name-of-language-server-executable'},
      root_dir = vim.fs.root(0, {'setup.py', 'pyproject.toml'}),
    })

3. Check that the server attached to the buffer: 
    :lua =vim.lsp.get_clients()

4. Configure keymaps and autocmds to use LSP features. See lsp-config.

                                                        lsp-config
                                                        lsp-defaults
When the LSP client starts it enables diagnostics vim.diagnostic (see
vim.diagnostic.config() to customize). It also sets various default options,
listed below, if (1) the language server supports the functionality and (2)
the options are empty or were set by the builtin runtime (ftplugin) files. The
options are not restored when the LSP client is stopped or detached.

- 'omnifunc' is set to vim.lsp.omnifunc(), use i_CTRL-X_CTRL-O to trigger
  completion.
- '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(), so you can format lines via
  gq if the language server supports it.
  - To opt out of this use gw instead of gq, or set 'formatexpr' on LspAttach.
- K is mapped to vim.lsp.buf.hover() unless 'keywordprg' is customized or
  a custom keymap for K exists.

                                                        lsp-defaults-disable
To override the above defaults, set or unset the options on LspAttach: 

    vim.api.nvim_create_autocmd('LspAttach', {
      callback = function(ev)
        vim.bo[ev.buf].formatexpr = nil
        vim.bo[ev.buf].omnifunc = nil
        vim.keymap.del('n', 'K', { buffer = ev.buf })
      end,
    })

To use other LSP features, set keymaps on LspAttach. Not all language
servers provide the same capabilities. To ensure you only set keymaps if the
language server supports a feature, guard keymaps behind capability checks.
Example: 

    vim.api.nvim_create_autocmd('LspAttach', {
      callback = function(args)
        local client = vim.lsp.get_client_by_id(args.data.client_id)
        if client.supports_method('textDocument/rename') then
          -- Create a keymap for vim.lsp.buf.rename()
        end
        if client.supports_method('textDocument/implementation') then
          -- Create a keymap for vim.lsp.buf.implementation
        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_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_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).
                                                                  lsp-method

Requests and notifications defined by the LSP specification are referred to as
"LSP methods". The Nvim LSP client provides default handlers in the global
vim.lsp.handlers table, you can list them with this command: 

    :lua vim.print(vim.tbl_keys(vim.lsp.handlers))

They are also listed below. Note that handlers depend on server support: they
won't run if your server doesn't support them.

- callHierarchy/incomingCalls
- callHierarchy/outgoingCalls
- textDocument/codeAction
- textDocument/completion
- textDocument/declaration*
- textDocument/definition
- textDocument/diagnostic
- textDocument/documentHighlight
- textDocument/documentSymbol
- textDocument/formatting
- textDocument/hover
- textDocument/implementation*
- textDocument/inlayHint
- textDocument/prepareTypeHierarchy
- textDocument/publishDiagnostics
- textDocument/rangeFormatting
- textDocument/references
- textDocument/rename
- textDocument/semanticTokens/full
- textDocument/semanticTokens/full/delta
- textDocument/signatureHelp
- textDocument/typeDefinition*
- typeHierarchy/subtypes
- typeHierarchy/supertypes
- window/logMessage
- window/showMessage
- window/showDocument
- window/showMessageRequest
- workspace/applyEdit
- workspace/configuration
- workspace/executeCommand
- workspace/inlayHint/refresh
- workspace/symbol
- workspace/workspaceFolders

                                                                 lsp-handler
LSP handlers are functions that handle lsp-responses to requests made by Nvim
to the server. (Notifications, as opposed to requests, are fire-and-forget:
there is no response, so they can't be handled. lsp-notification)

Each response handler has this signature: 

    function(err, result, ctx, config)

    Parameters: 
        - {err}     (table|nil) Error info dict, or nil if the request
                    completed.
        - {result}  (Result | Params | nil) result key of the lsp-response or
                    nil if the request failed.
        - {ctx}     (table) Table of calling state associated with the
                    handler, with these keys:
                    - {method}  (string) lsp-method name.
                    - {client_id} (number) vim.lsp.Client identifier.
                    - {bufnr}   (Buffer) Buffer handle.
                    - {params}  (table|nil) Request parameters table.
                    - {version} (number) Document version at time of
                                request. Handlers can compare this to the
                                current document version to check if the
                                response is "stale". See also b:changedtick.
        - {config}  (table) Handler-defined configuration table, which allows
                    users to customize handler behavior.
                    For an example, see:
                        vim.lsp.diagnostic.on_publish_diagnostics()
                    To configure a particular lsp-handler, see:
                        lsp-handler-configuration

    Returns: 
        Two values `result, err` where err is shaped like an RPC error: 
            { code, message, data? }
        You can use vim.lsp.rpc.rpc_response_error() to create this object.

                                                   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 of vim.lsp.start(). This sets the default
  lsp-handler for the server being started. Example: 

    vim.lsp.start {
      ..., -- Other configuration omitted.
      handlers = {
        ["textDocument/definition"] = my_custom_server_definition
      },
    }

- The {handler} parameter of vim.lsp.buf_request_all(). This sets
  the lsp-handler ONLY for the given request(s). Example: 

    vim.lsp.buf_request_all(
      0,
      "textDocument/definition",
      my_request_params,
      my_handler
    )

In summary, the lsp-handler will be chosen based on the current lsp-method
in the following order:

1. Handler passed to vim.lsp.buf_request_all(), if any.
2. Handler defined in vim.lsp.start(), 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-response
LSP response shape:
https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage

                                                                lsp-notification
LSP notification shape:
https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage

================================================================================
LSP HIGHLIGHT                                                    lsp-highlight

Reference Highlights:

Highlight groups that are meant to be used by vim.lsp.buf.document_highlight().

You can see more about the differences in types here:
https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight

                                                           hl-LspReferenceText
LspReferenceText          used for highlighting "text" references
                                                           hl-LspReferenceRead
LspReferenceRead          used for highlighting "read" references
                                                          hl-LspReferenceWrite
LspReferenceWrite         used for highlighting "write" references
                                                          hl-LspInlayHint
LspInlayHint              used for highlighting inlay hints


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

------------------------------------------------------------------------------
LSP SEMANTIC HIGHLIGHTS                               lsp-semantic-highlight

When available, the LSP client highlights code using lsp-semantic_tokens,
which are another way that LSP servers can provide information about source
code.  Note that this is in addition to treesitter syntax highlighting;
semantic highlighting does not replace syntax highlighting.

The server will typically provide one token per identifier in the source code.
The token will have a type such as "function" or "variable", and 0 or more
modifiers such as "readonly" or "deprecated." The standard types and
modifiers are described here:
https://microsoft.github.io/language-server-protocol/specification/#textDocument_semanticTokens
LSP servers may also use off-spec types and modifiers.

The LSP client adds one or more highlights for each token. The highlight
groups are derived from the token's type and modifiers:
  • @lsp.type.<type>.<ft> for the type
  • @lsp.mod.<mod>.<ft> for each modifier
  • @lsp.typemod.<type>.<mod>.<ft> for each modifier
Use :Inspect to view the highlights for a specific token. Use :hi or
nvim_set_hl() to change the appearance of semantic highlights: 

    hi @lsp.type.function guifg=Yellow        " function names are yellow
    hi @lsp.type.variable.lua guifg=Green     " variables in lua are green
    hi @lsp.mod.deprecated gui=strikethrough  " deprecated is crossed out
    hi @lsp.typemod.function.async guifg=Blue " async functions are blue

The value vim.highlight.priorities.semantic_tokens is the priority of the
@lsp.type.* highlights. The @lsp.mod.* and @lsp.typemod.* highlights
have priorities one and two higher, respectively.

You can disable semantic highlights by clearing the highlight groups: 

    -- Hide semantic highlights for functions
    vim.api.nvim_set_hl(0, '@lsp.type.function', {})

    -- Hide all semantic highlights
    for _, group in ipairs(vim.fn.getcompletion("@lsp", "highlight")) do
      vim.api.nvim_set_hl(0, group, {})
    end

You probably want these inside a ColorScheme autocommand.

Use LspTokenUpdate and vim.lsp.semantic_tokens.highlight_token() for more
complex highlighting.

The following is a list of standard captures used in queries for Nvim,
highlighted according to the current colorscheme (use :Inspect on one to see
the exact definition):

@lsp.type.class          Identifiers that declare or reference a class type
@lsp.type.comment        Tokens that represent a comment
@lsp.type.decorator      Identifiers that declare or reference decorators and annotations
@lsp.type.enum           Identifiers that declare or reference an enumeration type
@lsp.type.enumMember     Identifiers that declare or reference an enumeration property, constant, or member
@lsp.type.event          Identifiers that declare an event property
@lsp.type.function       Identifiers that declare a function
@lsp.type.interface      Identifiers that declare or reference an interface type
@lsp.type.keyword        Tokens that represent a language keyword
@lsp.type.macro          Identifiers that declare a macro
@lsp.type.method         Identifiers that declare a member function or method
@lsp.type.modifier       Tokens that represent a modifier
@lsp.type.namespace      Identifiers that declare or reference a namespace, module, or package
@lsp.type.number         Tokens that represent a number literal
@lsp.type.operator       Tokens that represent an operator
@lsp.type.parameter      Identifiers that declare or reference a function or method parameters
@lsp.type.property       Identifiers that declare or reference a member property, member field, or member variable
@lsp.type.regexp         Tokens that represent a regular expression literal
@lsp.type.string         Tokens that represent a string literal
@lsp.type.struct         Identifiers that declare or reference a struct type
@lsp.type.type           Identifiers that declare or reference a type that is not covered above
@lsp.type.typeParameter  Identifiers that declare or reference a type parameter
@lsp.type.variable       Identifiers that declare or reference a local or global variable

@lsp.mod.abstract        Types and member functions that are abstract
@lsp.mod.async           Functions that are marked async
@lsp.mod.declaration     Declarations of symbols
@lsp.mod.defaultLibrary  Symbols that are part of the standard library
@lsp.mod.definition      Definitions of symbols, for example, in header files
@lsp.mod.deprecated      Symbols that should no longer be used
@lsp.mod.documentation   Occurrences of symbols in documentation
@lsp.mod.modification    Variable references where the variable is assigned to
@lsp.mod.readonly        Readonly variables and member fields (constants)
@lsp.mod.static          Class members (static members)

==============================================================================
EVENTS                                                            lsp-events

LspAttach                                                          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                                                          LspDetach
    Just before an LSP client detaches from a buffer. The autocmd-pattern
    is the name of the buffer. When used from Lua, the client ID is passed
    to the callback in the "data" table. Example: 

    vim.api.nvim_create_autocmd("LspDetach", {
      callback = function(args)
        local client = vim.lsp.get_client_by_id(args.data.client_id)
        -- Do something with the client
        vim.cmd("setlocal tagfunc< omnifunc<")
      end,
    })


LspNotify                                                          LspNotify
    This event is triggered after each successful notification sent to an
    LSP server.

    When used from Lua, the client_id, LSP method, and parameters are sent
    in the "data" table. Example: 

    vim.api.nvim_create_autocmd('LspNotify', {
      callback = function(args)
        local bufnr = args.buf
        local client_id = args.data.client_id
        local method = args.data.method
        local params = args.data.params

        -- do something with the notification
        if method == 'textDocument/...' then
          update_buffer(bufnr)
        end
      end,
    })


LspProgress                                                       LspProgress
    Upon receipt of a progress notification from the server. Notifications can
    be polled from a progress ring buffer of a vim.lsp.Client or use
    vim.lsp.status() to get an aggregate message.

    If the server sends a "work done progress", the pattern is set to kind
    (one of begin, report or end).

    When used from Lua, the event contains a data table with client_id and
    params properties. params will contain the request params sent by the
    server (see lsp.ProgressParams).

    Example: 
        autocmd LspProgress * redrawstatus


LspRequest                                                        LspRequest
    For each request sent to an LSP server, this event is triggered for
    every change to the request's status. The status can be one of
    pending, complete, or cancel and is sent as the {type} on the
    "data" table passed to the callback function.

    It triggers when the initial request is sent ({type} == pending) and
    when the LSP server responds ({type} == complete). If a cancellation
    is requested using client.cancel_request(request_id), then this event
    will trigger with {type} == cancel.

    When used from Lua, the client ID, request ID, and request are sent in
    the "data" table. See {requests} in vim.lsp.Client for details on the
    {request} value. If the request type is complete, the request will be
    deleted from the client's pending requests table immediately after
    calling the event's callbacks. Example: 

    vim.api.nvim_create_autocmd('LspRequest', {
      callback = function(args)
        local bufnr = args.buf
        local client_id = args.data.client_id
        local request_id = args.data.request_id
        local request = args.data.request
        if request.type == 'pending' then
          -- do something with pending requests
          track_pending(client_id, bufnr, request_id, request)
        elseif request.type == 'cancel' then
          -- do something with pending cancel requests
          track_canceling(client_id, bufnr, request_id, request)
        elseif request.type == 'complete' then
          -- do something with finished requests. this pending
          -- request entry is about to be removed since it is complete
          track_finish(client_id, bufnr, request_id, request)
        end
      end,
    })


LspTokenUpdate                                                LspTokenUpdate
    When a visible semantic token is sent or updated by the LSP server, or
    when an existing token becomes visible for the first time. The
    autocmd-pattern is the name of the buffer. When used from Lua, the
    token and client ID are passed to the callback in the "data" table. The
    token fields are documented in vim.lsp.semantic_tokens.get_at_pos().
    Example:
    

    vim.api.nvim_create_autocmd('LspTokenUpdate', {
      callback = function(args)
        local token = args.data.token
        if token.type == 'variable' and not token.modifiers.readonly then
          vim.lsp.semantic_tokens.highlight_token(
            token, args.buf, args.data.client_id, 'MyMutableVariableHighlight'
          )
        end
      end,
    })

    Note: doing anything other than calling
    vim.lsp.semantic_tokens.highlight_token() is considered experimental.

==============================================================================
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}      (`integer`) Buffer handle, or 0 for current
      • {client_id}  (`integer`) Client id

    Return: 
        (`boolean`) success true if client was attached successfully;
        false otherwise

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}      (`integer`) Buffer handle, or 0 for current
      • {client_id}  (`integer`) 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}      (`integer`) Buffer handle, or 0 for current
      • {client_id}  (`integer`) the client id

buf_notify({bufnr}, {method}, {params})                 vim.lsp.buf_notify()
    Send a notification to a server

    Parameters: {bufnr}   (`integer?`) The number of the buffer
      • {method}  (`string`) Name of the request method{params}  (`any`) Arguments to send to the server

    Return: 
        (`boolean`) success true if any client returns true; false otherwise

                                                   vim.lsp.buf_request_all()
buf_request_all({bufnr}, {method}, {params}, {handler})
    Sends an async request for all active clients attached to the buffer and
    executes the handler callback with the combined result.

    Parameters: {bufnr}    (`integer`) Buffer handle, or 0 for current.
      • {method}   (`string`) LSP method name
      • {params}   (`table?`) Parameters to send to the server
      • {handler}  (`function`) Handler called after all requests are
                   completed. Server results are passed as a
                   client_id:result map.

    Return: 
        (`function`) cancel Function that cancels all requests.

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

    Calls vim.lsp.buf_request_all() but blocks Nvim while awaiting the
    result. Parameters are the same as vim.lsp.buf_request_all() but the
    result is different. Waits a maximum of {timeout_ms}.

    Parameters: {bufnr}       (`integer`) Buffer handle, or 0 for current.
      • {method}      (`string`) LSP method name
      • {params}      (`table?`) Parameters to send to the server
      • {timeout_ms}  (`integer?`, default: 1000) Maximum time in
                      milliseconds to wait for a result.

    Return (multiple): 
        (`table<integer, {error: lsp.ResponseError?, result: any}>?`) result
        Map of client_id:request_result.
        (`string?`) err On timeout, cancel, or error, err is a string
        describing the failure reason, and result is nil.

client_is_stopped({client_id})                   vim.lsp.client_is_stopped()
    Checks whether a client is stopped.

    Parameters: {client_id}  (`integer`)

    Return: 
        (`boolean`) stopped true if client is stopped, false otherwise.

commands                                                    vim.lsp.commands
    Registry for client side commands. This is an extension point for plugins
    to handle custom commands which are not part of the core language server
    protocol specification.

    The registry is a table where the key is a unique command name, and the
    value is a function which is called if any LSP action (code action, code
    lenses, ...) triggers the command.

    If a LSP response contains a command for which no matching entry is
    available in this registry, the command will be executed via the LSP
    server using workspace/executeCommand.

    The first argument to the function will be the Command: Command title:
    String command: String arguments?: any[]

    The second argument is the ctx of lsp-handler

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 via
    `setlocal formatexpr=v:lua.vim.lsp.formatexpr()` but will typically or in
    on_attach via
    `vim.bo[bufnr].formatexpr = 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})'`.

    Parameters: {opts}  (`table?`) A table with the following fields:
                • {timeout_ms} (`integer`, default: 500ms) The timeout period
                  for the formatting request..

                                          vim.lsp.get_buffers_by_client_id()
get_buffers_by_client_id({client_id})
    Returns list of buffers attached to client_id.

    Parameters: {client_id}  (`integer`) client id

    Return: 
        (`integer[]`) buffers 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}  (`integer`) client id

    Return: 
        (`vim.lsp.Client?`) client rpc object

get_clients({filter})                                  vim.lsp.get_clients()
    Get active clients.

    Parameters: {filter}  (`table?`) Key-value pairs used to filter the returned
                  clients.
                  • {id}? (`integer`) Only return clients with the given id
                  • {bufnr}? (`integer`) Only return clients attached to this
                    buffer
                  • {name}? (`string`) Only return clients with the given name
                  • {method}? (`string`) Only return clients supporting the
                    given method

    Return: 
        (`vim.lsp.Client[]`) List of vim.lsp.Client objects

get_log_path()                                        vim.lsp.get_log_path()
    Gets the path of the logfile used by the LSP client.

    Return: 
        (`string`) path to log file

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

    Parameters: {findstart}  (`integer`) 0 or 1, decides behavior
      • {base}       (`integer`) findstart=0, text to match against

    Return: 
        (`integer|table`) Decided by {findstart}:
        • findstart=0: column where the completion starts, or -2 or -3
        • findstart=1: list of matches (actually just calls complete())

    See also: complete-functionscomplete-itemsCompleteDone

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}  (`integer|string`) the case insensitive level name or number

    See also: vim.lsp.log_levels

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.root(0, {'pyproject.toml', 'setup.py'}),
        })


    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 string[] or function, described at
      vim.lsp.start_client().root_dir path to the project root. By default this is used to decide
      if an existing client should be re-used. The example above uses
      vim.fs.root() and vim.fs.dirname() to detect the root by traversing
      the file system upwards starting from the current directory until either
      a pyproject.toml or setup.py file is found.
    • workspace_folders list of `{ uri:string, name: string }` tables
      specifying the project root folders used by the language server. If
      nil the property is derived from root_dir for convenience.

    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}  (`vim.lsp.ClientConfig`) Configuration for the server. See
                  vim.lsp.ClientConfig.{opts}    (`table?`) Optional keyword arguments
                  • {reuse_client}
                    (`fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig): boolean`)
                    Predicate used to decide if a client should be re-used.
                    Used on all running clients. The default implementation
                    re-uses a client if name and root_dir matches.
                  • {bufnr} (`integer`) Buffer handle to attach to if starting
                    or re-using a client (0 for current).
                  • {silent}? (`boolean`) Suppress error reporting if the LSP
                    server fails to start (default false).

    Return: 
        (`integer?`) client_id

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

    Parameters: {config}  (`vim.lsp.ClientConfig`) Configuration for the server. See
                  vim.lsp.ClientConfig.

    Return (multiple): 
        (`integer?`) client_id vim.lsp.get_client_by_id() Note: client may
        not be fully initialized. Use on_init to do any actions once the
        client has been initialized.
        (`string?`) Error message, if any

status()                                                    vim.lsp.status()
    Consumes the latest progress messages from all clients and formats them as
    a string. Empty if there are no clients or if no new messages

    Return: 
        (`string`)

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


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

    Parameters: {client_id}  (`integerinteger[]vim.lsp.Client[]`) id, list of id's,
                     or list of vim.lsp.Client objects{force}      (`boolean?`) shutdown forcefully

tagfunc({pattern}, {flags})                                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}  (`string`) Pattern used to find a workspace symbol
      • {flags}    (`string`) See tag-function

    Return: 
        (`table[]`) tags A list of matching tags

with({handler}, {override_config})                            vim.lsp.with()
    Function to manage overriding defaults for LSP handlers.

    Parameters: {handler}          (`lsp.Handler`) See lsp-handler{override_config}  (`table`) Table containing the keys to override
                           behavior of the {handler}


==============================================================================
Lua module: vim.lsp.client                                        lsp-client

vim.lsp.Client

    Fields: {id}                    (`integer`) The id allocated to the client.
      • {name}                  (`string`) If a name is specified on creation,
                                that will be used. Otherwise it is just the
                                client id. This is used for logs and messages.
      • {rpc}                   (`vim.lsp.rpc.PublicClient`) RPC client
                                object, for low level interaction with the
                                client. See vim.lsp.rpc.start().{offset_encoding}       (`string`) The encoding used for communicating
                                with the server. You can modify this in the
                                config's on_init method before text is
                                sent to the server.
      • {handlers}              (`table<string,lsp.Handler>`) The handlers
                                used by the client as described in
                                lsp-handler.{requests}              (`table<integer,{ type: string, bufnr: integer, method: string}>`)
                                The current pending requests in flight to the
                                server. Entries are key-value pairs with the
                                key being the request id while the value is a
                                table with type, bufnr, and method
                                key-value pairs. type is either "pending"
                                for an active request, or "cancel" for a
                                cancel request. It will be "complete"
                                ephemerally while executing LspRequest
                                autocmds when replies are received from the
                                server.
      • {config}                (`vim.lsp.ClientConfig`) copy of the table
                                that was passed by the user to
                                vim.lsp.start_client(). See
                                vim.lsp.ClientConfig.{server_capabilities}   (`lsp.ServerCapabilities?`) Response from the
                                server sent on initialize describing the
                                server's capabilities.
      • {progress}              (`vim.lsp.Client.Progress`) A ring buffer
                                (vim.ringbuf()) containing progress messages
                                sent by the server. See
                                vim.lsp.Client.Progress.{initialized}           (`true?`)
      • {workspace_folders}     (`lsp.WorkspaceFolder[]?`) The workspace
                                folders configured in the client when the
                                server starts. This property is only available
                                if the client supports workspace folders. It
                                can be null if the client supports workspace
                                folders but none are configured.
      • {root_dir}              (`string`)
      • {attached_buffers}      (`table<integer,true>`)
      • {commands}              (`table<string,fun(command: lsp.Command, ctx: table)>`)
                                Table of command name to function which is
                                called if any LSP action (code action, code
                                lenses, ...) triggers the command. Client
                                commands take precedence over the global
                                command registry.
      • {settings}              (`table`) Map with language server specific
                                settings. These are returned to the language
                                server if requested via
                                workspace/configuration. Keys are
                                case-sensitive.
      • {flags}                 (`table`) A table with flags for the client.
                                The current (experimental) flags are:
                                • {allow_incremental_sync}? (`boolean`,
                                  default: true) Allow using incremental
                                  sync for buffer edits
                                • {debounce_text_changes} (`integer`, default:
                                  150) Debounce didChange notifications to
                                  the server by the given number in
                                  milliseconds. No debounce occurs if nil.
                                • {exit_timeout} (`integer|false`, default:
                                  false) Milliseconds to wait for server to
                                  exit cleanly after sending the "shutdown"
                                  request before sending kill -15. If set to
                                  false, nvim exits immediately after sending
                                  the "shutdown" request to the server.
      • {get_language_id}       (`fun(bufnr: integer, filetype: string): string`)
      • {capabilities}          (`lsp.ClientCapabilities`) The capabilities
                                provided by the client (editor or tool)
      • {dynamic_capabilities}  (`lsp.DynamicCapabilities`)
      • {request}               (`fun(method: string, params: table?, handler: lsp.Handler?, bufnr: integer?): boolean, integer?`)
                                Sends a request to the server. This is a thin
                                wrapper around {client.rpc.request} with some
                                additional checking. If {handler} is not
                                specified and if there's no respective global
                                handler, then an error will occur. Returns:
                                {status}, {client_id}?. {status} is a boolean
                                indicating if the notification was successful.
                                If it is false, then it will always be
                                false (the client has shutdown). If {status}
                                is true, the function returns {request_id}
                                as the second result. You can use this with
                                client.cancel_request(request_id) to cancel
                                the request.
      • {request_sync}          (`fun(method: string, params: table?, timeout_ms: integer?, bufnr: integer): {err: lsp.ResponseError?, result:any}?, string?`)
                                err # a dictionary, where
      • {notify}                (`fun(method: string, params: table?): boolean`)
                                Sends a notification to an LSP server.
                                Returns: a boolean to indicate if the
                                notification was successful. If it is false,
                                then it will always be false (the client has
                                shutdown).
      • {cancel_request}        (`fun(id: integer): boolean`) Cancels a
                                request with a given request id. Returns: same
                                as notify().
      • {stop}                  (`fun(force?: boolean)`) Stops a client,
                                optionally with force. By default, it will
                                just ask the server to shutdown without force.
                                If you request to stop a client which has
                                previously been requested to shutdown, it will
                                automatically escalate and force shutdown.
      • {on_attach}             (`fun(bufnr: integer)`) Runs the on_attach
                                function from the client's config if it was
                                defined. Useful for buffer-local setup.
      • {supports_method}       (`fun(method: string, opts?: {bufnr: integer?}): boolean`)
                                Checks if a client supports a given method.
                                Always returns true for unknown off-spec
                                methods. {opts} is a optional
                                `{bufnr?: integer}` table. Some language
                                server capabilities can be file specific.
      • {is_stopped}            (`fun(): boolean`) Checks whether a client is
                                stopped. Returns: true if the client is fully
                                stopped.

vim.lsp.Client.Progress
    Extends: vim.Ringbuf


    Fields: {pending}  (`table<lsp.ProgressToken,lsp.LSPAny>`)

vim.lsp.ClientConfig

    Fields: {cmd}                 (`string[]|fun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient`)
                              command string[] that launches the language
                              server (treated as in jobstart(), must be
                              absolute or on $PATH, shell constructs like
                              "~" are not expanded), or function that creates
                              an RPC client. Function receives a dispatchers
                              table and returns a table with member functions
                              request, notify, is_closing and
                              terminate. See vim.lsp.rpc.request(),
                              vim.lsp.rpc.notify(). For TCP there is a
                              builtin RPC client factory:
                              vim.lsp.rpc.connect(){cmd_cwd}?            (`string`, default: cwd) Directory to launch the
                              cmd process. Not related to root_dir.
      • {cmd_env}?            (`table`) Environment flags to pass to the LSP
                              on spawn. Must be specified using a table.
                              Non-string values are coerced to string.
                              Example: 
                                  { PORT = 8080; HOST = "0.0.0.0"; }{detached}?           (`boolean`, default: true) Daemonize the server
                              process so that it runs in a separate process
                              group from Nvim. Nvim will shutdown the process
                              on exit, but if Nvim fails to exit cleanly this
                              could leave behind orphaned server processes.
      • {workspace_folders}?  (`lsp.WorkspaceFolder[]`) List of workspace
                              folders passed to the language server. For
                              backwards compatibility rootUri and rootPath
                              will be derived from the first workspace folder
                              in this list. See workspaceFolders in the LSP
                              spec.
      • {capabilities}?       (`lsp.ClientCapabilities`) Map overriding the
                              default capabilities defined by
                              vim.lsp.protocol.make_client_capabilities(),
                              passed to the language server on initialization.
                              Hint: use make_client_capabilities() and modify
                              its result.
                              • Note: To send an empty dictionary use
                                vim.empty_dict(), else it will be encoded as
                                an array.
      • {handlers}?           (`table<string,function>`) Map of language
                              server method names to lsp-handler{settings}?           (`table`) Map with language server specific
                              settings. See the {settings} in
                              vim.lsp.Client.{commands}?           (`table<string,fun(command: lsp.Command, ctx: table)>`)
                              Table that maps string of clientside commands to
                              user-defined functions. Commands passed to
                              start_client take precedence over the global
                              command registry. Each key must be a unique
                              command name, and the value is a function which
                              is called if any LSP action (code action, code
                              lenses, ...) triggers the command.
      • {init_options}?       (`table`) Values to pass in the initialization
                              request as initializationOptions. See
                              initialize in the LSP spec.
      • {name}?               (`string`, default: client-id) Name in log
                              messages.
      • {get_language_id}?    (`fun(bufnr: integer, filetype: string): string`)
                              Language ID as string. Defaults to the filetype.
      • {offset_encoding}?    (`'utf-8''utf-16''utf-32'`) The encoding that
                              the LSP server expects. Client does not verify
                              this is correct.
      • {on_error}?           (`fun(code: integer, err: string)`) Callback
                              invoked when the client operation throws an
                              error. code is a number describing the error.
                              Other arguments may be passed depending on the
                              error kind. See vim.lsp.rpc.client_errors for
                              possible errors. Use
                              vim.lsp.rpc.client_errors[code] to get
                              human-friendly name.
      • {before_init}?        (`fun(params: lsp.InitializeParams, config: vim.lsp.ClientConfig)`)
                              Callback invoked before the LSP "initialize"
                              phase, where params contains the parameters
                              being sent to the server and config is the
                              config that was passed to
                              vim.lsp.start_client(). You can use this to
                              modify parameters before they are sent.
      • {on_init}?            (`elem_or_list<fun(client: vim.lsp.Client, initialize_result: lsp.InitializeResult)>`)
                              Callback invoked after LSP "initialize", where
                              result is a table of capabilities and
                              anything else the server may send. For example,
                              clangd sends initialize_result.offsetEncoding
                              if capabilities.offsetEncoding was sent to it.
                              You can only modify the client.offset_encoding
                              here before any notifications are sent.
      • {on_exit}?            (`elem_or_list<fun(code: integer, signal: integer, client_id: integer)>`)
                              Callback invoked on client exit.
                              • code: exit code of the process
                              • signal: number describing the signal used to
                                terminate (if any)
                              • client_id: client handle
      • {on_attach}?          (`elem_or_list<fun(client: vim.lsp.Client, bufnr: integer)>`)
                              Callback invoked when client attaches to a
                              buffer.
      • {trace}?              (`'off''messages''verbose'`, default: "off")
                              Passed directly to the language server in the
                              initialize request. Invalid/empty values will
      • {flags}?              (`table`) A table with flags for the client. The
                              current (experimental) flags are:
                              • {allow_incremental_sync}? (`boolean`, default:
                                true) Allow using incremental sync for
                                buffer edits
                              • {debounce_text_changes} (`integer`, default:
                                150) Debounce didChange notifications to
                                the server by the given number in
                                milliseconds. No debounce occurs if nil.
                              • {exit_timeout} (`integer|false`, default:
                                false) Milliseconds to wait for server to
                                exit cleanly after sending the "shutdown"
                                request before sending kill -15. If set to
                                false, nvim exits immediately after sending
                                the "shutdown" request to the server.
      • {root_dir}?           (`string`) Directory where the LSP server will
                              base its workspaceFolders, rootUri, and rootPath
                              on initialization.



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

vim.lsp.ListOpts

    Fields: {on_list}?  (`fun(t: vim.lsp.LocationOpts.OnList)`) list-handler
                    replacing the default handler. Called for any non-empty
                    result. This table can be used with setqflist() or
                    setloclist(). E.g.: 
                        local function on_list(options)
                          vim.fn.setqflist({}, ' ', options)
                          vim.cmd.cfirst()
                        end

                        vim.lsp.buf.definition({ on_list = on_list })
                        vim.lsp.buf.references(nil, { on_list = on_list })


                    If you prefer loclist instead of qflist: 
                        vim.lsp.buf.definition({ loclist = true })
                        vim.lsp.buf.references(nil, { loclist = true }){loclist}?  (`boolean`)

vim.lsp.LocationOpts
    Extends: vim.lsp.ListOpts


    Fields: {reuse_win}?  (`boolean`) Jump to existing window if buffer is already
                      open.

vim.lsp.LocationOpts.OnList

    Fields: {items}     (`table[]`) Structured like setqflist-what{title}?    (`string`) Title for the list.
      • {context}?  (`table`) ctx from lsp-handler


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

    Parameters: {workspace_folder}  (`string?`)

clear_references()                            vim.lsp.buf.clear_references()
    Removes document highlights from current buffer.

code_action({opts})                                vim.lsp.buf.code_action()
    Selects a code action available at the current cursor position.

    Parameters: {opts}  (`table?`) A table with the following fields:
                • {context}? (`lsp.CodeActionContext`) Corresponds to
                  CodeActionContext of the LSP specification:
                  • {diagnostics}? (`table`) LSP Diagnostic[]. Inferred from
                    the current position if not provided.
                  • {only}? (`table`) List of LSP CodeActionKinds used to
                    filter the code actions. Most language servers support
                    values like refactor or quickfix.
                  • {triggerKind}? (`integer`) The reason why code actions
                    were requested.
                • {filter}? (`fun(x: lsp.CodeAction|lsp.Command):boolean`)
                  Predicate taking an CodeAction and returning a boolean.
                • {apply}? (`boolean`) When set to true, and there is just
                  one remaining action (after filtering), the action is
                  applied without user query.
                • {range}? (`{start: integer[], end: integer[]}`) Range for
                  which code actions should be requested. If in visual mode
                  this defaults to the active selection. Table must contain
                  start and end keys with {row,col} tuples using mark-like
                  indexing. See api-indexing

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_codeAction
      • vim.lsp.protocol.CodeActionTriggerKind

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

    Parameters: {context}  (`table`) (context support not yet implemented) Additional
                   information about the context in which a completion was
                   triggered (how it was triggered, and by which trigger
                   character, if applicable)

    See also: 
      • vim.lsp.protocol.CompletionTriggerKind

declaration({opts})                                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: {opts}  (`vim.lsp.LocationOpts?`) See vim.lsp.LocationOpts.

definition({opts})                                  vim.lsp.buf.definition()
    Jumps to the definition of the symbol under the cursor.

    Parameters: {opts}  (`vim.lsp.LocationOpts?`) See vim.lsp.LocationOpts.

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({opts})                        vim.lsp.buf.document_symbol()
    Lists all symbols in the current buffer in the quickfix window.

    Parameters: {opts}  (`vim.lsp.ListOpts?`) See vim.lsp.ListOpts.

execute_command({command_params})              vim.lsp.buf.execute_command()
    Executes an LSP server command.

    Parameters: {command_params}  (`lsp.ExecuteCommandParams`)

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand

format({opts})                                          vim.lsp.buf.format()
    Formats a buffer using the attached (and optionally filtered) language
    server clients.

    Parameters: {opts}  (`table?`) A table with the following fields:
                • {formatting_options}? (`table`) Can be used to specify
                  FormattingOptions. Some unspecified options will be
                  automatically derived from the current Nvim options. See
                  https://microsoft.github.io/language-server-protocol/specification/#formattingOptions{timeout_ms}? (`integer`, default: 1000) Time in
                  milliseconds to block for formatting requests. No effect if
                  async=true.
                • {bufnr}? (`integer`, default: current buffer) Restrict
                  formatting to the clients attached to the given buffer.
                • {filter}? (`fun(client: vim.lsp.Client): boolean?`)
                  Predicate used to filter clients. Receives a client as
                  argument and must return a boolean. Clients matching the
                  predicate are included. Example: 
                    -- Never request typescript-language-server for formatting
                    vim.lsp.buf.format {
                      filter = function(client) return client.name ~= "tsserver" end
                    }{async}? (`boolean`, default: false) If true the method
                  won't block. Editing the buffer while formatting
                  asynchronous can lead to unexpected changes.
                • {id}? (`integer`) Restrict formatting to the client with ID
                  (client.id) matching this field.
                • {name}? (`string`) Restrict formatting to the client with
                  name (client.name) matching this field.
                • {range}? (`{start:integer[],end:integer[]}`, default:
                  current selection in visual mode, nil in other modes,
                  formatting the full buffer) Range to format. Table must
                  contain start and end keys with {row,col} tuples using
                  (1,0) indexing.

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

    Parameters: {opts}  (`vim.lsp.LocationOpts?`) See vim.lsp.LocationOpts.

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}, {opts})                       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
      • {opts}     (`vim.lsp.ListOpts?`) See vim.lsp.ListOpts.

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references

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

    Parameters: {workspace_folder}  (`string?`)

rename({new_name}, {opts})                              vim.lsp.buf.rename()
    Renames all references to the symbol under the cursor.

    Parameters: {new_name}  (`string?`) If not provided, the user will be prompted for
                    a new name using vim.ui.input().{opts}      (`table?`) Additional options:
                    • {filter}? (`fun(client: vim.lsp.Client): boolean?`)
                      Predicate used to filter clients. Receives a client as
                      argument and must return a boolean. Clients matching the
                      predicate are included.
                    • {name}? (`string`) Restrict clients used for rename to
                      ones where client.name matches this field.
                    • {bufnr}? (`integer`) (default: current buffer)

signature_help()                                vim.lsp.buf.signature_help()
    Displays signature information about the symbol under the cursor in a
    floating window.

type_definition({opts})                        vim.lsp.buf.type_definition()
    Jumps to the definition of the type of the symbol under the cursor.

    Parameters: {opts}  (`vim.lsp.LocationOpts?`) See vim.lsp.LocationOpts.

typehierarchy({kind})                            vim.lsp.buf.typehierarchy()
    Lists all the subtypes or supertypes of the symbol under the cursor in the
    quickfix window. If the symbol can resolve to multiple items, the user
    can pick one using vim.ui.select().

    Parameters: {kind}  (`"subtypes"|"supertypes"`)

workspace_symbol({query}, {opts})             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
      • {opts}   (`vim.lsp.ListOpts?`) See vim.lsp.ListOpts.


==============================================================================
Lua module: vim.lsp.diagnostic                                lsp-diagnostic

                                          vim.lsp.diagnostic.get_namespace()
get_namespace({client_id}, {is_pull})
    Get the diagnostic namespace associated with an LSP client
    vim.diagnostic for diagnostics

    Parameters: {client_id}  (`integer`) The id of the LSP client
      • {is_pull}    (`boolean?`) Whether the namespace is for a pull or push
                     client. Defaults to push

                                          vim.lsp.diagnostic.on_diagnostic()
on_diagnostic({_}, {result}, {ctx}, {config})
    lsp-handler for the method "textDocument/diagnostic"

    See vim.diagnostic.config() for configuration options. Handler-specific
    configuration can be set using vim.lsp.with(): 
        vim.lsp.handlers["textDocument/diagnostic"] = vim.lsp.with(
          vim.lsp.diagnostic.on_diagnostic, {
            -- Enable underline, use default values
            underline = true,
            -- Enable virtual text, override spacing to 4
            virtual_text = {
              spacing = 4,
            },
            -- Use a function to dynamically turn signs off
            -- and on, using buffer local variables
            signs = function(namespace, bufnr)
              return vim.b[bufnr].show_signs == true
            end,
            -- Disable a feature
            update_in_insert = false,
          }
        )


    Parameters: {result}  (`lsp.DocumentDiagnosticReport`)
      • {ctx}     (`lsp.HandlerContext`)
      • {config}  (`vim.diagnostic.Opts`) Configuration table (see
                  vim.diagnostic.config()).

                                 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: {result}  (`lsp.PublishDiagnosticsParams`)
      • {ctx}     (`lsp.HandlerContext`)
      • {config}  (`vim.diagnostic.Opts?`) Configuration table (see
                  vim.diagnostic.config()).


==============================================================================
Lua module: vim.lsp.codelens                                    lsp-codelens

clear({client_id}, {bufnr})                         vim.lsp.codelens.clear()
    Clear the lenses

    Parameters: {client_id}  (`integer?`) filter by client_id. All clients if nil
      • {bufnr}      (`integer?`) filter by buffer. All buffers if nil, 0 for
                     current buffer

display({lenses}, {bufnr}, {client_id})           vim.lsp.codelens.display()
    Display the lenses using virtual text

    Parameters: {lenses}     (`lsp.CodeLens[]?`) lenses to display
      • {bufnr}      (`integer`)
      • {client_id}  (`integer`)

get({bufnr})                                          vim.lsp.codelens.get()
    Return all lenses for the given buffer

    Parameters: {bufnr}  (`integer`) Buffer number. 0 can be used for the current
                 buffer.

    Return: 
        (`lsp.CodeLens[]`)

on_codelens({err}, {result}, {ctx})           vim.lsp.codelens.on_codelens()
    lsp-handler for the method textDocument/codeLens

    Parameters: {err}     (`lsp.ResponseError?`)
      • {result}  (`lsp.CodeLens[]`)
      • {ctx}     (`lsp.HandlerContext`)

refresh({opts})                                   vim.lsp.codelens.refresh()
    Refresh the lenses.

    It is recommended to trigger this using an autocmd or via keymap.

    Example: 
        autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh({ bufnr = 0 })


    Parameters: {opts}  (`table?`) Optional fields
                • {bufnr} (`integer?`) filter by buffer. All buffers if nil, 0
                  for current buffer

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}     (`lsp.CodeLens[]?`) lenses to store
      • {bufnr}      (`integer`)
      • {client_id}  (`integer`)


==============================================================================
Lua module: vim.lsp.inlay_hint                                lsp-inlay_hint

enable({enable}, {filter})                       vim.lsp.inlay_hint.enable()
    Enables or disables inlay hints for the {filter}ed scope.

    To "toggle", pass the inverse of is_enabled(): 
        vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())


    Parameters: {enable}  (`boolean?`) true/nil to enable, false to disable
      • {filter}  (`table?`) Optional filters kwargs, or nil for all.
                  • {bufnr} (`integer?`) Buffer number, or 0 for current
                    buffer, or nil for all.

get({filter})                                       vim.lsp.inlay_hint.get()
    Get the list of inlay hints, (optionally) restricted by buffer or range.

    Example usage: 
        local hint = vim.lsp.inlay_hint.get({ bufnr = 0 })[1] -- 0 for current buffer

        local client = vim.lsp.get_client_by_id(hint.client_id)
        local resp = client.request_sync('inlayHint/resolve', hint.inlay_hint, 100, 0)
        local resolved_hint = assert(resp and resp.result, resp.err)
        vim.lsp.util.apply_text_edits(resolved_hint.textEdits, 0, client.encoding)

        location = resolved_hint.label[1].location
        client.request('textDocument/hover', {
          textDocument = { uri = location.uri },
          position = location.range.start,
        })


    Parameters: {filter}  (`table?`) Optional filters kwargs:{bufnr} (`integer?`)
                  • {range} (`lsp.Range?`)

    Return: 
        (`table[]`) A list of objects with the following fields:
        • {bufnr} (`integer`)
        • {client_id} (`integer`)
        • {inlay_hint} (`lsp.InlayHint`)

is_enabled({filter})                         vim.lsp.inlay_hint.is_enabled()
    Query whether inlay hint is enabled in the {filter}ed scope

    Parameters: {filter}  (`table`) Optional filters kwargs, or nil for all.
                  • {bufnr} (`integer?`) Buffer number, or 0 for current
                    buffer, or nil for all.

    Return: 
        (`boolean`)


==============================================================================
Lua module: vim.lsp.semantic_tokens                      lsp-semantic_tokens

force_refresh({bufnr})               vim.lsp.semantic_tokens.force_refresh()
    Force a refresh of all semantic tokens

    Only has an effect if the buffer is currently active for semantic token
    highlighting (vim.lsp.semantic_tokens.start() has been called for it)

    Parameters: {bufnr}  (`integer?`) filter by buffer. All buffers if nil, current
                 buffer if 0

                                        vim.lsp.semantic_tokens.get_at_pos()
get_at_pos({bufnr}, {row}, {col})
    Return the semantic token(s) at the given position. If called without
    arguments, returns the token under the cursor.

    Parameters: {bufnr}  (`integer?`) Buffer number (0 for current buffer, default)
      • {row}    (`integer?`) Position row (default cursor position)
      • {col}    (`integer?`) Position column (default cursor position)

    Return: 
        (`table?`) List of tokens at position. Each token has the following
        fields:
        • line (integer) line number, 0-based
        • start_col (integer) start column, 0-based
        • end_col (integer) end column, 0-based
        • type (string) token type as string, e.g. "variable"
        • modifiers (table) token modifiers as a set. E.g., { static = true,
          readonly = true }
        • client_id (integer)

                                   vim.lsp.semantic_tokens.highlight_token()
highlight_token({token}, {bufnr}, {client_id}, {hl_group}, {opts})
    Highlight a semantic token.

    Apply an extmark with a given highlight group for a semantic token. The
    mark will be deleted by the semantic token engine when appropriate; for
    example, when the LSP sends updated tokens. This function is intended for
    use inside LspTokenUpdate callbacks.

    Parameters: {token}      (`table`) a semantic token, found as args.data.token in
                     LspTokenUpdate.{bufnr}      (`integer`) the buffer to highlight
      • {client_id}  (`integer`) The ID of the vim.lsp.Client{hl_group}   (`string`) Highlight group name
      • {opts}       (`table?`) Optional parameters:
                     • {priority}? (`integer`, default:
                       `vim.highlight.priorities.semantic_tokens + 3`)
                       Priority for the applied extmark.

start({bufnr}, {client_id}, {opts})          vim.lsp.semantic_tokens.start()
    Start the semantic token highlighting engine for the given buffer with the
    given client. The client must already be attached to the buffer.

    NOTE: This is currently called automatically by
    vim.lsp.buf_attach_client(). To opt-out of semantic highlighting with a
    server that supports it, you can delete the semanticTokensProvider table
    from the {server_capabilities} of your client in your LspAttach callback
    or your configuration's on_attach callback: 
        client.server_capabilities.semanticTokensProvider = nil


    Parameters: {bufnr}      (`integer`)
      • {client_id}  (`integer`)
      • {opts}       (`table?`) Optional keyword arguments
                     • debounce (integer, default: 200): Debounce token
                       requests to the server by the given number in
                       milliseconds

stop({bufnr}, {client_id})                    vim.lsp.semantic_tokens.stop()
    Stop the semantic token highlighting engine for the given buffer with the
    given client.

    NOTE: This is automatically called by a LspDetach autocmd that is set up
    as part of start(), so you should only need this function to manually
    disengage the semantic token engine without fully detaching the LSP client
    from the buffer.

    Parameters: {bufnr}      (`integer`)
      • {client_id}  (`integer`)


==============================================================================
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: {result}  (`lsp.Hover`)
      • {ctx}     (`lsp.HandlerContext`)
      • {config}  (`table`) Configuration table.
                  • border: (default=nil)
                    • Add borders to the floating window
                    • See vim.lsp.util.open_floating_preview() for more
                      options.

                                           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: {result}  (`lsp.SignatureHelp`) Response from the language server
      • {ctx}     (`lsp.HandlerContext`) Client context{config}  (`table`) Configuration table.
                  • border: (default=nil)
                    • Add borders to the floating window
                    • See vim.lsp.util.open_floating_preview() for more
                      options


==============================================================================
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}               (`integer`) Optional index of the edit, if from
                              a list of edits (or nil, if not from a list)
      • {offset_encoding}     (`string?`)

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentEdit

                                             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}            (`integer`) Buffer id
      • {offset_encoding}  (`string`) utf-8utf-16utf-32

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit

                                         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-8utf-16utf-32 (required)

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_applyEdit

buf_clear_references({bufnr})            vim.lsp.util.buf_clear_references()
    Removes document highlights from a buffer.

    Parameters: {bufnr}  (`integer?`) Buffer id

                                     vim.lsp.util.buf_highlight_references()
buf_highlight_references({bufnr}, {references}, {offset_encoding})
    Shows a list of document highlights for a certain buffer.

    Parameters: {bufnr}            (`integer`) Buffer id
      • {references}       (`table`) List of DocumentHighlight objects to
                           highlight
      • {offset_encoding}  (`string`) One of "utf-8", "utf-16", "utf-32".

    See also: https://microsoft.github.io/language-server-protocol/specification/#textDocumentContentChangeEvent

                                             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}              (`integer`) buffer number (0 for current)
      • {row}              (`integer`) 0-indexed line
      • {col}              (`integer`) 0-indexed byte offset in line
      • {offset_encoding}  (`string`) utf-8utf-16utf-32 defaults to
                           offset_encoding of first client of buf

    Return: 
        (`integer`) offset_encoding index of the character in line {row}
        column {col} in buffer {buf}

                              vim.lsp.util.convert_input_to_markdown_lines()
convert_input_to_markdown_lines({input}, {contents})
    Converts any of MarkedString | MarkedString[] | MarkupContent into a
    list of lines containing valid markdown. Useful to populate the hover
    window for textDocument/hover, for parsing the result of
    textDocument/signatureHelp, and potentially others.

    Note that if the input is of type MarkupContent and its kind is
    plaintext, then the corresponding value is returned without further
    modifications.

    Parameters: {input}     (`lsp.MarkedStringlsp.MarkedString[]lsp.MarkupContent`)
      • {contents}  (`table?`) List of strings to extend with converted lines.
                    Defaults to {}.

    Return: 
        (`string[]`) extended with lines of converted markdown.

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover

                     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}  (`table`) Response of textDocument/SignatureHelp{ft}              (`string?`) filetype that will be use as the lang
                          for the label markdown code block
      • {triggers}        (`table?`) list of trigger characters from the lsp
                          server. used to better determine parameter offsets

    Return (multiple): 
        (`table?`) table list of lines of converted markdown.
        (`table?`) table of active hl

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_signatureHelp

get_effective_tabstop({bufnr})          vim.lsp.util.get_effective_tabstop()
    Returns indentation size.

    Parameters: {bufnr}  (`integer?`) Buffer handle, defaults to current

    Return: 
        (`integer`) 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}  (`string?`) utf-8utf-16utf-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 user_data field of each resulting item will contain the original
    Location or LocationLink it was computed from.

    The result can be passed to the {list} argument of setqflist() or
    setloclist().

    Parameters: {locations}        (`lsp.Location[]|lsp.LocationLink[]`)
      • {offset_encoding}  (`string`) offset_encoding for locations
                           utf-8utf-16utf-32 default to first client of
                           buffer

    Return: 
        (`table[]`) A list of objects with the following fields:
        • {filename} (`string`)
        • {lnum} (`integer`) 1-indexed line number
        • {col} (`integer`) 1-indexed column
        • {text} (`string`)
        • {user_data} (`lsp.Location|lsp.LocationLink`)

                                  vim.lsp.util.make_floating_popup_options()
make_floating_popup_options({width}, {height}, {opts})
    Creates a table with sensible default options for a floating window. The
    table can be passed to nvim_open_win().

    Parameters: {width}   (`integer`) window width (in character cells)
      • {height}  (`integer`) window height (in character cells)
      • {opts}    (`table`) optional
                  • offset_x (integer) offset to add to col
                  • offset_y (integer) 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
                  • relative ("mouse"|"cursor") defaults to "cursor"
                  • anchor_bias ("auto"|"above"|"below") defaults to "auto"
                    • "auto": place window based on which side of the cursor
                      has more lines
                    • "above": place the window above the cursor unless there
                      are not enough lines to display the full window height.
                    • "below": place the window below the cursor unless there
                      are not enough lines to display the full window height.

    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?`) with valid FormattingOptions entries

    Return: 
        (`lsp.DocumentFormattingParams`) object

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_formatting

                                      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}        (`integer[]?`) {row,col} mark-indexed position.
                           Defaults to the start of the last visual selection.
      • {end_pos}          (`integer[]?`) {row,col} mark-indexed position.
                           Defaults to the end of the last visual selection.
      • {bufnr}            (`integer?`) buffer handle or 0 for current,
                           defaults to current
      • {offset_encoding}  (`"utf-8"|"utf-16"|"utf-32"?`) defaults to
                           offset_encoding of first client of bufnr

    Return: 
        (`table`) { textDocument = { uri = `current_file_uri` }, range = {
        start = start_position, end = end_position } }

                                         vim.lsp.util.make_position_params()
make_position_params({window}, {offset_encoding})
    Creates a TextDocumentPositionParams object for the current buffer and
    cursor position.

    Parameters: {window}           (`integer?`) window handle or 0 for current,
                           defaults to current
      • {offset_encoding}  (`string?`) utf-8utf-16utf-32|nil defaults to
                           offset_encoding of first client of buffer of
                           window

    Return: 
        (`table`) TextDocumentPositionParams object

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentPositionParams

                                            vim.lsp.util.make_range_params()
make_range_params({window}, {offset_encoding})
    Using the current position in the current buffer, creates an object that
    can be used as a building block for several LSP requests, such as
    textDocument/codeAction, textDocument/colorPresentation,
    textDocument/rangeFormatting.

    Parameters: {window}           (`integer?`) window handle or 0 for current,
                           defaults to current
      • {offset_encoding}  (`"utf-8"|"utf-16"|"utf-32"?`) defaults to
                           offset_encoding of first client of buffer of
                           window

    Return: 
        (`table`) { textDocument = { uri = `current_file_uri` }, range = {
        start = current_position, end = current_position } }

                                    vim.lsp.util.make_text_document_params()
make_text_document_params({bufnr})
    Creates a TextDocumentIdentifier object for the current buffer.

    Parameters: {bufnr}  (`integer?`) Buffer handle, defaults to current

    Return: 
        (`table`) TextDocumentIdentifier

    See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentIdentifier

                                        vim.lsp.util.make_workspace_params()
make_workspace_params({added}, {removed})
    Create the workspace params

    Parameters: {added}    (`table`)
      • {removed}  (`table`)

                                        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
                    filtered with vim.lsp.util.make_floating_popup_options()
                    before they are passed on to nvim_open_win()){height}? (`integer`) Height of floating window{width}? (`integer`) Width of floating window{wrap}? (`boolean`, default: true) Wrap long lines
                    • {wrap_at}? (`integer`) Character to wrap at for
                      computing height when wrap is enabled
                    • {max_width}? (`integer`) Maximal width of floating
                      window{max_height}? (`integer`) Maximal height of floating
                      window{focus_id}? (`string`) If a popup with this id is
                      opened, then focus it{close_events}? (`table`) List of events that closes the
                      floating window{focusable}? (`boolean`, default: true) Make float
                      focusable.
                    • {focus}? (`boolean`, default: true) If true, and if
                      {focusable} is also true, focus an existing floating
                      window with the same {focus_id}

    Return (multiple): 
        (`integer`) bufnr of newly created float window
        (`integer`) winid of newly created float window preview window

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}  (`table`) a single Location or LocationLink{opts}      (`table`)

    Return (multiple): 
        (`integer?`) buffer id of float window
        (`integer?`) window id of float window

rename({old_fname}, {new_fname}, {opts})               vim.lsp.util.rename()
    Rename old_fname to new_fname

    Existing buffers are renamed as well, while maintaining their bufnr.

    It deletes existing buffers that conflict with the renamed file name only
    when
    • opts requests overwriting; or
    • the conflicting buffers are not loaded, so that deleting them does not
      result in data loss.

    Parameters: {old_fname}  (`string`)
      • {new_fname}  (`string`)
      • {opts}       (`table?`) Options:
                     • {overwrite}? (`boolean`)
                     • {ignoreIfExists}? (`boolean`)

                                                vim.lsp.util.show_document()
show_document({location}, {offset_encoding}, {opts})
    Shows document and optionally jumps to the location.

    Parameters: {location}         (`table`) (`Location`|LocationLink)
      • {offset_encoding}  (`string?`) utf-8utf-16utf-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: {bufnr}     (`integer`)
      • {contents}  (`table`) of lines to show in window{opts}      (`table`) 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
                    • separator insert separator after code block

    Return: 
        (`table`) stripped content

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

    Parameters: {symbols}  (`table`) DocumentSymbol[] or SymbolInformation[]
      • {bufnr}    (`integer`)


==============================================================================
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: 
        (`integer`) 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|integer`) One of vim.lsp.log.levels

should_log({level})                                 vim.lsp.log.should_log()
    Checks whether the level is sufficient for logging.

    Parameters: {level}  (`integer`) log level

    Return: 
        (`bool`) true if would log, false if not


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

vim.lsp.rpc.PublicClient

    Fields: {request}     (`fun(method: string, params: table?, callback: fun(err: lsp.ResponseError?, result: any), notify_reply_callback: fun(integer)?):boolean,integer?`)
                      see vim.lsp.rpc.request(){notify}      (`fun(method: string, params: any):boolean`) see
                      vim.lsp.rpc.notify(){is_closing}  (`fun(): boolean`)
      • {terminate}   (`fun()`)


connect({host_or_path}, {port})                        vim.lsp.rpc.connect()
    Create a LSP RPC client factory that connects to either:
    • a named pipe (windows)
    • a domain socket (unix)
    • a host and port via TCP

    Return a function that can be passed to the cmd field for
    vim.lsp.start_client() or vim.lsp.start().

    Parameters: {host_or_path}  (`string`) host to connect to or path to a pipe/domain
                        socket
      • {port}          (`integer?`) TCP port to connect to. If absent the
                        first argument must be a pipe

    Return: 
        (`fun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient`)

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`) error_message 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?`) Parameters for the invoked LSP method

    Return: 
        (`boolean`) true if notification could be sent, false if not

                                                       vim.lsp.rpc.request()
request({method}, {params}, {callback}, {notify_reply_callback})
    Sends a request to the LSP server and runs {callback} upon response.

    Parameters: {method}                 (`string`) The invoked LSP method{params}                 (`table?`) Parameters for the invoked LSP
                                 method{callback}               (`fun(err: lsp.ResponseError?, result: any)`)
                                 Callback to invoke
      • {notify_reply_callback}  (`fun(message_id: integer)?`) Callback to
                                 invoke as soon as a request is no longer
                                 pending

    Return (multiple): 
        (`boolean`) success true if request could be sent, false if not
        (`integer?`) message_id if request could be sent, nil if not

                                            vim.lsp.rpc.rpc_response_error()
rpc_response_error({code}, {message}, {data})
    Creates an RPC response table error to be sent to the LSP response.

    Parameters: {code}     (`integer`) RPC error code defined, see
                   vim.lsp.protocol.ErrorCodes{message}  (`string?`) arbitrary message to send to server
      • {data}     (`any?`) arbitrary data to send to server

    Return: 
        (`lsp.ResponseError`)

    See also: 
      • lsp.ErrorCodes See vim.lsp.protocol.ErrorCodes

start({cmd}, {dispatchers}, {extra_spawn_params})        vim.lsp.rpc.start()
    Starts an LSP server process and create an LSP RPC client object to
    interact with it. Communication with the spawned process happens via
    stdio. For communication via TCP, spawn a process manually and use
    vim.lsp.rpc.connect()

    Parameters: {cmd}                 (`string[]`) Command to start the LSP server.
      • {dispatchers}         (`table?`) Dispatchers for LSP message types.
                              • {notification}
                                (`fun(method: string, params: table)`)
                              • {server_request}
                                (`fun(method: string, params: table): any?, lsp.ResponseError?`)
                              • {on_exit}
                                (`fun(code: integer, signal: integer)`)
                              • {on_error} (`fun(code: integer, err: any)`)
      • {extra_spawn_params}  (`table?`) Additional context for the LSP server
                              process.
                              • {cwd}? (`string`) Working directory for the
                                LSP server process
                              • {detached}? (`boolean`) Detach the LSP server
                                process from the current process
                              • {env}? (`table<string,string>`) Additional
                                environment variables for LSP server process.
                                See vim.system()

    Return: 
        (`vim.lsp.rpc.PublicClient`) Client RPC object, with these methods:
        • notify() vim.lsp.rpc.notify()request() vim.lsp.rpc.request()is_closing() returns a boolean indicating if the RPC is closing.
        • terminate() terminates the RPC client. See
          vim.lsp.rpc.PublicClient.


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

    Return: 
        (`lsp.ClientCapabilities`)

Methods                                             vim.lsp.protocol.Methods
    LSP method names.

    See also: https://microsoft.github.io/language-server-protocol/specification/#metaModel

                                     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: 
        (`lsp.ServerCapabilities?`) Normalized table of capabilities


 vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl:


Quick links: help overview · quick reference · user manual toc · reference manual toc