vim.lsp

Export these directly from rpc.

Called by the client when trying to call a method that's not supported in any of the servers registered for the current buffer.

Returns full text of buffer {bufnr} as a string.

Sets the default configuration for an LSP client (or all clients if the special name "*" is used).

Can also be accessed by table-indexing (vim.lsp.config[…]) to get the resolved config, or redefine the config (instead of "merging" with the config chain).

Examples:

• Add root markers for ALL clients:

  vim.lsp.config('*', {
      root_markers = { '.git', '.hg' },
    })

• Add capabilities to ALL clients:

  vim.lsp.config('*', {
    capabilities = {
      textDocument = {
        semanticTokens = {
          multilineTokenSupport = true,
        }
      }
    }
  })

• Add root markers and capabilities for "clangd":

  vim.lsp.config('clangd', {
    root_markers = { '.clang-format', 'compile_commands.json' },
    capabilities = {
      textDocument = {
        completion = {
          completionItem = {
            snippetSupport = true,
          }
        }
      }
    }
  })

• (Re-)define the "clangd" configuration (overrides the resolved chain):

  vim.lsp.config.clangd = {
    cmd = {
      'clangd',
      '--clang-tidy',
      '--background-index',
      '--offset-encoding=utf-8',
    },
    root_markers = { '.clangd', 'compile_commands.json' },
    filetypes = { 'c', 'cpp' },
  }

• Get the resolved configuration for "emmylua_ls":

  local cfg = vim.lsp.config.emmylua_ls

Gets LSP configs.

See also [vim.lsp.getclients()] to get the runtime values of dynamic fields like `rootdir`, which depend on the current buffer/workspace/etc.

WARNING: May eagerly (prematurely!) evaluate config files in 'runtimepath'.

Enables a [lsp-config]: automatically attaches the client to any buffer based on the config filetypes, root_markers, and root_dir. See [lsp-activate] for details.

To disable, pass enable=false: Stops related clients and servers (force-stops servers after a timeout, unless exit_timeout=false).

Raises an error under the following conditions:

• {name} is not a valid LSP config name (for example, '*').
• {name} corresponds to an LSP config file which raises an error.

If an error is raised when multiple names are provided, this function will have no side-effects; it will not enable/disable any configs, including ones which contain no errors.

Examples:

vim.lsp.enable('clangd')
vim.lsp.enable({'emmylua_ls', 'pyright'})

Example: To dynamically decide whether LSP is activated, define a |lsp-root_dir()| function which calls on_dir() only when you want that config to activate:

vim.lsp.config('emmylua_ls', {
  root_dir = function(bufnr, on_dir)
    if vim.fs.ext(vim.fn.bufname(bufnr)) ~= 'txt' then
      on_dir(vim.fn.getcwd())
    end
  end
})

Checks if the given LSP config is enabled (globally, not per-buffer).

Unlike vim.lsp.config['…'], this does not have the side-effect of resolving the config.

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.ClientConfig| 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. See also |lsp-server|.
• root_dir path to the project root. By default this is used to decide if an existing client

should be re-used. The example above uses |vim.fs.root()| to detect the root by traversing the file system upwards starting from the current directory until either a pyproject.toml or setup.py file is found.

• workspace_folders list of { uri:string, name: string } tables specifying the project root

folders used by the language server. If nil the property is derived from root_dir for convenience.

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|, |nvimcreateautocmd()| or put the call in a ftplugin/<filetype_name>.lua (See |ftplugin-name|)

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

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.

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.

Checks if a buffer is attached for a particular client.

Gets a client by id, or nil if the id is invalid or the client was stopped. The returned client may not yet be fully initialized.

Gets active clients.

Sends an async request for all active clients attached to the buffer and executes the handler callback with the combined result.

Sends a request to all server and waits for the response of all of them.

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

Send a notification to a server

Implements 'omnifunc' compatible LSP completion.

Provides an interface between the built-in client and a formatexpr function.

Currently only supports a single client. This can be set via vim.bo[bufnr].formatexpr = vim.lsp.formatexpr, or with a wrapper to pass options:

vim.bo[bufnr].formatexpr = function()
  return vim.lsp.formatexpr({ timeout_ms = 250 })
end

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.

Provides an interface between the built-in client and a foldexpr function.

To use, set 'foldmethod' to "expr" and set the value of 'foldexpr':

vim.o.foldmethod = 'expr'
vim.o.foldexpr = vim.lsp.foldexpr

Or use it only when supported by checking for the "textDocument/foldingRange" capability in an |LspAttach| autocommand. Example:

vim.o.foldmethod = 'expr'
-- Default to treesitter folding
vim.o.foldexpr = vim.treesitter.foldexpr
-- Prefer LSP folding if client supports it
vim.api.nvim_create_autocmd('LspAttach', {
  callback = function(ev)
    local client = vim.lsp.get_client_by_id(ev.data.client_id)
    if client:supports_method('textDocument/foldingRange') then
      local win = vim.api.nvim_get_current_win()
      vim.wo[win][0].foldexpr = vim.lsp.foldexpr
    end
  end,
})

Close all {kind} of folds in the window with {winid}.

To automatically fold imports when opening a file, you can use an autocmd:

vim.api.nvim_create_autocmd('LspNotify', {
  callback = function(ev)
    if ev.data.method == 'textDocument/didOpen' then
      vim.lsp.foldclose('imports', vim.fn.bufwinid(ev.buf))
    end
  end,
})

Provides a foldtext function that shows the collapsedText retrieved, defaults to the first folded line if collapsedText is not provided.

The displayed foldtext will be highlighted via treesitter.

Error codes to be used with on_error from |vim.lsp.start_client|. Can be used to look up the string from a the number or the number from the string.

Log level dictionary with reverse lookup as well.

Can be used to lookup the number from the name or the name from the number. Levels by name: "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF" Level numbers begin with "TRACE" at 0

Map of client-defined handlers implementing custom (off-spec) commands which a server may invoke. Each key is a unique command name; each value is a function which is called when an LSP action (code action, code lenses, …) requests it by name.

If an LSP response requests a command not defined client-side, Nvim will forward it to the server as workspace/executeCommand.

• Argument 1 is the Command:

  Command
    title: String
    command: String
    arguments?: any[]

• Argument 2 is the |lsp-handler| ctx.

Example:

vim.lsp.commands['java.action.generateToStringPrompt'] = function(_, ctx)
  require("jdtls.async").run(function()
    local _, result = request(ctx.bufnr, 'java/checkToStringStatus', ctx.params)
    local fields = ui.pick_many(result.fields, 'Include item in toString?', function(x)
      return string.format('%s: %s', x.name, x.type)
    end)
    local _, edit = request(ctx.bufnr, 'java/generateToString', { context = ctx.params; fields = fields; })
    vim.lsp.util.apply_workspace_edit(edit, offset_encoding)
  end)
end