Nvim:help pages,generated fromsource using thetree-sitter-vimdoc parser.
vim.lsp for buildingenhanced LSP tools.vim.lsp.config['lua_ls'] = { -- Command and arguments to start the server. cmd = { 'lua-language-server' }, -- Filetypes to automatically attach to. filetypes = { 'lua' }, -- Sets the "workspace" to the directory where any of these files is found. -- Files that share a root directory will reuse the LSP server connection. -- Nested lists indicate equal priority, see |vim.lsp.Config|. root_markers = { { '.luarc.json', '.luarc.jsonc' }, '.git' }, -- Specific settings to send to the server. The schema is server-defined. -- Example: https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json settings = { Lua = { runtime = { version = 'LuaJIT', } } }}vim.lsp.enable('lua_ls')filetypes specified in the config. Note: Depending on the LSP server, you may need to ensure your project has alsp-root_markers file so the workspace can be recognized.:checkhealth vim.lspCTRL-S (Insert mode) is mapped tovim.lsp.buf.signature_help()vim.lsp.document_color.enable(false, args.buf) onLspAttach.vim.api.nvim_create_autocmd('LspAttach', { callback = function(args) -- Unset 'formatexpr' vim.bo[args.buf].formatexpr = nil -- Unset 'omnifunc' vim.bo[args.buf].omnifunc = nil -- Unmap K vim.keymap.del('n', 'K', { buffer = args.buf }) -- Disable document colors vim.lsp.document_color.enable(false, args.buf) end,})vim.lsp.config() or createalsp/<config-name>.lua file.:lua vim.lsp.config('foo', {cmd={'true'}})2. Run:lua vim.lsp.enable('foo')3. Run:checkhealth vim.lsp, check "Enabled Configurations". 😎lsp/foo.lua somewhere on your'runtimepath'.:exe 'edit' stdpath('config') .. '/lsp/foo.lua'2. Add this code to the file (or copy an example fromhttps://github.com/neovim/nvim-lspconfig):return { cmd = { 'true' },}3. Save the file (with++p to ensure its parent directory is created).:write ++p4. Enable the config.
:lua vim.lsp.enable('foo')5. Run:checkhealth vim.lsp, check "Enabled Configurations". 🌈'*' name.2. The merged configuration of alllsp/<config>.lua files in'runtimepath' for the config named<config>.3. The merged configuration of allafter/lsp/<config>.lua files in'runtimepath'.lsp/*.lua configs provided by plugins (such as nvim-lspconfig).4. Configurations defined anywhere else.-- Defined in init.luavim.lsp.config('*', { capabilities = { textDocument = { semanticTokens = { multilineTokenSupport = true, } } }, root_markers = { '.git' },})-- Defined in <rtp>/lsp/clangd.luareturn { cmd = { 'clangd' }, root_markers = { '.clangd', 'compile_commands.json' }, filetypes = { 'c', 'cpp' },}-- Defined in init.luavim.lsp.config('clangd', { filetypes = { 'c' },}){ -- From the clangd configuration in <rtp>/lsp/clangd.lua cmd = { 'clangd' }, -- From the clangd configuration in <rtp>/lsp/clangd.lua -- Overrides the "*" configuration in init.lua root_markers = { '.clangd', 'compile_commands.json' }, -- From the clangd configuration in init.lua -- Overrides the clangd configuration in <rtp>/lsp/clangd.lua filetypes = { 'c' }, -- From the "*" configuration in init.lua capabilities = { textDocument = { semanticTokens = { multilineTokenSupport = true, } } }}supports_method() in yourLspAttach handler.lsp-lintlsp-formatExample: Enable auto-completion and auto-formatting ("linting"):vim.api.nvim_create_autocmd('LspAttach', { group = vim.api.nvim_create_augroup('my.lsp', {}), callback = function(args) local client = assert(vim.lsp.get_client_by_id(args.data.client_id)) if client:supports_method('textDocument/implementation') then -- Create a keymap for vim.lsp.buf.implementation ... end -- Enable auto-completion. Note: Use CTRL-Y to select an item. |complete_CTRL-Y| if client:supports_method('textDocument/completion') then -- Optional: trigger autocompletion on EVERY keypress. May be slow! -- local chars = {}; for i = 32, 126 do table.insert(chars, string.char(i)) end -- client.server_capabilities.completionProvider.triggerCharacters = chars vim.lsp.completion.enable(true, client.id, args.buf, {autotrigger = true}) end -- Auto-format ("lint") on save. -- Usually not needed if server supports "textDocument/willSaveWaitUntil". if not client:supports_method('textDocument/willSaveWaitUntil') and client:supports_method('textDocument/formatting') then vim.api.nvim_create_autocmd('BufWritePre', { group = vim.api.nvim_create_augroup('my.lsp', {clear=false}), buffer = args.buf, callback = function() vim.lsp.buf.format({ bufnr = args.buf, id = client.id, timeout_ms = 1000 }) end, }) end end,}):lua =vim.lsp.get_clients()[1].server_capabilities:lua vim.iter(vim.lsp.get_clients()):each(function(client) client:stop() end):edit:verbose set omnifunc?async parameter and set the value to false. E.g. code formatting:" Auto-format *.rs (rust) files prior to saving them" (async = false is the default for format)autocmd BufWritePre *.rs lua vim.lsp.buf.format({ async = false }):lua vim.print(vim.tbl_keys(vim.lsp.handlers))'callHierarchy/incomingCalls''callHierarchy/outgoingCalls''client/registerCapability''client/unregisterCapability''signature_help''textDocument/codeLens''textDocument/completion''textDocument/diagnostic''textDocument/documentHighlight''textDocument/documentSymbol''textDocument/formatting''textDocument/hover''textDocument/inlayHint''textDocument/inlineCompletion''textDocument/publishDiagnostics''textDocument/rangeFormatting''textDocument/rename''textDocument/signatureHelp''typeHierarchy/subtypes''typeHierarchy/supertypes''window/logMessage''window/showDocument''window/showMessage''window/showMessageRequest''window/workDoneProgress/create''workspace/applyEdit''workspace/configuration''workspace/executeCommand''workspace/inlayHint/refresh''workspace/semanticTokens/refresh''workspace/symbol''workspace/workspaceFolders'function(err, result, ctx)
{err} (table|nil) Error info dict, ornil if the request completed.{ctx} (table) Table of calling state associated with the handler, with these keys:{bufnr} (Buffer) Buffer handle.{params} (table|nil) Request parameters table.{version} (number) Document version at time of request. Handlers can compare this to the current document version to check if the response is "stale". See alsob:changedtick.result, err whereerr is shaped like an RPC error:{ code, message, data? }vim.lsp.buf and related interfaces).local client = assert(vim.lsp.get_clients()[1])client:request('textDocument/definition')vim.lsp.handlers. This global table contains the default mappings oflsp-method names to handlers. (Note: only for server-to-client requests/notifications, not client-to-server.) Example:vim.lsp.handlers['textDocument/publishDiagnostics'] = my_custom_diagnostics_handler{handlers} parameter tovim.lsp.start(). This sets the defaultlsp-handler for a specific server. (Note: only for server-to-client requests/notifications, not client-to-server.) Example:vim.lsp.start { ..., -- Other configuration omitted. handlers = { ['textDocument/publishDiagnostics'] = my_custom_diagnostics_handler },}{handler} parameter tovim.lsp.buf_request_all(). This sets thelsp-handler ONLY for the given request(s). Example:vim.lsp.buf_request_all( 0, 'textDocument/publishDiagnostics', my_request_params, my_handler)vim.lsp.protocol defines constants dictated by the LSP specification,and helper functions for creating protocol-related objects.https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.mdvim.lsp.protocol.ErrorCodes allows reverse lookup by number orname:vim.lsp.protocol.TextDocumentSyncKind.Full == 1vim.lsp.protocol.TextDocumentSyncKind[1] == "Full"type such as "function" or "variable", and 0 or moremodifiers such as "readonly" or "deprecated." The standard types andmodifiers are described here:https://microsoft.github.io/language-server-protocol/specification/#textDocument_semanticTokensLSP servers may also use off-spec types and modifiers.@lsp.type.<type>.<ft> for the type@lsp.mod.<mod>.<ft> for each modifier@lsp.typemod.<type>.<mod>.<ft> for each modifierUse:Inspect to view the highlights for a specific token. Use:hi ornvim_set_hl() to change the appearance of semantic highlights:hi @lsp.type.function guifg=Yellow " function names are yellowhi @lsp.type.variable.lua guifg=Green " variables in lua are greenhi @lsp.mod.deprecated gui=strikethrough " deprecated is crossed outhi @lsp.typemod.function.async guifg=Blue " async functions are blue.semantic_tokens is the priority of the@lsp.type.* highlights. The@lsp.mod.* and@lsp.typemod.* highlightshave priorities one and two higher, respectively.-- Hide semantic highlights for functionsvim.api.nvim_set_hl(0, '@lsp.type.function', {})-- Hide all semantic highlightsfor _, group in ipairs(vim.fn.getcompletion("@lsp", "highlight")) do vim.api.nvim_set_hl(0, group, {})endvim.api.nvim_create_autocmd('LspAttach', { callback = function(ev) local client = vim.lsp.get_client_by_id(ev.data.client_id) -- ... end})vim.lsp.handlers['client/registerCapability'] = (function(overridden) return function(err, res, ctx) local result = overridden(err, res, ctx) local client = vim.lsp.get_client_by_id(ctx.client_id) if not client then return end for bufnr, _ in pairs(client.attached_buffers) do -- Call your custom on_attach logic... -- my_on_attach(client, bufnr) end return result endend)(vim.lsp.handlers['client/registerCapability'])vim.api.nvim_create_autocmd('LspDetach', { callback = function(args) -- Get the detaching client local client = vim.lsp.get_client_by_id(args.data.client_id) -- Remove the autocommand to format the buffer on save, if it exists if client:supports_method('textDocument/formatting') then vim.api.nvim_clear_autocmds({ event = 'BufWritePre', buffer = args.buf, }) end end,})vim.api.nvim_create_autocmd('LspNotify', { callback = function(args) local bufnr = args.buf local client_id = args.data.client_id local method = args.data.method local params = args.data.params -- do something with the notification if method == 'textDocument/...' then update_buffer(bufnr) end end,})progress ring buffer of avim.lsp.Client or usevim.lsp.status() to get an aggregate message.pattern is set tokind (one ofbegin,report orend).client_id andparams properties, whereparams is the request params sent by the server (seelsp.ProgressParams).autocmd LspProgress * redrawstatusvim.api.nvim_create_autocmd('LspProgress', { callback = function(ev) local value = ev.data.params.value if value.kind == 'begin' then vim.api.nvim_ui_send('\027]9;4;1;0\027\\') elseif value.kind == 'end' then vim.api.nvim_ui_send('\027]9;4;0\027\\') elseif value.kind == 'report' then vim.api.nvim_ui_send(string.format('\027]9;4;1;%d\027\\', value.percentage or 0)) end end,})pending,complete, orcancel and is sent as the{type} on the "data" table passed to the callback function.{type} ==pending) and when the LSP server responds ({type} ==complete). If a cancellation is requested usingclient.cancel_request(request_id), then this event will trigger with{type} ==cancel.{requests} field). If the request type iscomplete, the request will be deleted from the client's pending requests table after processing the event handlers.vim.api.nvim_create_autocmd('LspRequest', { callback = function(args) local bufnr = args.buf local client_id = args.data.client_id local request_id = args.data.request_id local request = args.data.request if request.type == 'pending' then -- do something with pending requests track_pending(client_id, bufnr, request_id, request) elseif request.type == 'cancel' then -- do something with pending cancel requests track_canceling(client_id, bufnr, request_id, request) elseif request.type == 'complete' then -- do something with finished requests. this pending -- request entry is about to be removed since it is complete track_finish(client_id, bufnr, request_id, request) end end,})vim.api.nvim_create_autocmd('LspTokenUpdate', { callback = function(args) local token = args.data.token if token.type == 'variable' and not token.modifiers.readonly then vim.lsp.semantic_tokens.highlight_token( token, args.buf, args.data.client_id, 'MyMutableVariableHighlight' ) end end,}){cmd}? (string[]|fun(dispatchers: vim.lsp.rpc.Dispatchers, config: vim.lsp.ClientConfig): vim.lsp.rpc.PublicClient) Seecmd invim.lsp.ClientConfig. See alsoreuse_client to dynamically decide (per-buffer) whencmd should be re-invoked.{filetypes}? (string[]) Filetypes the client will attach to, ornil for ALL filetypes. To match files by name, pattern, or contents, you can define a custom filetype usingvim.filetype.add():vim.filetype.add({ filename = { ['my_filename'] = 'my_filetype1', }, pattern = { ['.*/etc/my_file_pattern/.*'] = 'my_filetype2', },})vim.lsp.config('…', { filetypes = { 'my_filetype1', 'my_filetype2' },}{reuse_client}? (fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig): boolean) Predicate which decides if a client should be re-used. Used on all running clients. The default implementation re-uses a client if name and root_dir matches.{root_dir}? (string|fun(bufnr: integer, on_dir:fun(root_dir?:string)))lsp-root_dir() Decides the workspace root: the directory where the LSP server will base its workspaceFolders, rootUri, and rootPath on initialization. The function form must call theon_dir callback to provide the root dir, or LSP will not be activated for the buffer. Thus aroot_dir() function can dynamically decide per-buffer whether to activate (or skip) LSP. See example atvim.lsp.enable().{root_markers}? ((string|string[])[])lsp-root_markersroot_dir is defined. The list order decides priority. To indicate "equal priority", specify names in a nested list{ { 'a.txt', 'b.lua' }, ... }.root_markers = { 'stylua.toml', '.git' }root_markers = { { 'stylua.toml', '.luarc.json' }, '.git' }{bufnr},{client_id})vim.lsp.buf_attach_client()textDocument/did… notifications required to track a buffer for any language server.{bufnr} (integer) Buffer handle, or 0 for current{client_id} (integer) Client idboolean) successtrue if client was attached successfully;false otherwise{bufnr},{client_id})vim.lsp.buf_detach_client(){bufnr} (integer) Buffer handle, or 0 for current{client_id} (integer) Client id{bufnr},{client_id})vim.lsp.buf_is_attached(){bufnr} (integer) Buffer handle, or 0 for current{client_id} (integer) the client id{bufnr} (integer?) The number of the buffer{method} (string) Name of the request method{params} (any) Arguments to send to the serverboolean) success true if any client returns true; false otherwise{bufnr},{method},{params},{handler}) Sends an async request for all active clients attached to the buffer and executes thehandler callback with the combined result.{bufnr} (integer) Buffer handle, or 0 for current.{method} (string) LSP method name{params} (table|(fun(client: vim.lsp.Client, bufnr: integer): table?)?) Parameters to send to the server. Can also be passed as a function that returns the params table for cases where parameters are specific to the client.{handler} (function) Handler called after all requests are completed. Server results are passed as aclient_id:result map.function) cancel Function that cancels all requests.{bufnr},{method},{params},{timeout_ms}) Sends a request to all server and waits for the response of all of them.{timeout_ms}.{bufnr} (integer) Buffer handle, or 0 for current.{method} (string) LSP method name{params} (table|(fun(client: vim.lsp.Client, bufnr: integer): table?)?) Parameters to send to the server. Can also be passed as a function that returns the params table for cases where parameters are specific to the client.{timeout_ms} (integer?, default:1000) Maximum time in milliseconds to wait for a result.table<integer, {error: lsp.ResponseError?, result: any}>?) result Map of client_id:request_result. (string?) err On timeout, cancel, or error,err is a string describing the failure reason, andresult is nil.workspace/executeCommand.Command:Commandtitle: Stringcommand: Stringarguments?: any[]
ctx.vim.lsp.commands['java.action.generateToStringPrompt'] = function(_, ctx) require("jdtls.async").run(function() local _, result = request(ctx.bufnr, 'java/checkToStringStatus', ctx.params) local fields = ui.pick_many(result.fields, 'Include item in toString?', function(x) return string.format('%s: %s', x.name, x.type) end) local _, edit = request(ctx.bufnr, 'java/generateToString', { context = ctx.params; fields = fields; }) vim.lsp.util.apply_workspace_edit(edit, offset_encoding) end)end{name},{cfg})vim.lsp.config()vim.lsp.config[…]) to get the resolved config, or redefine the config (instead of "merging" with the config chain).vim.lsp.config('*', { root_markers = { '.git', '.hg' },}) vim.lsp.config('*', { capabilities = { textDocument = { semanticTokens = { multilineTokenSupport = true, } } }}) vim.lsp.config('clangd', { root_markers = { '.clang-format', 'compile_commands.json' }, capabilities = { textDocument = { completion = { completionItem = { snippetSupport = true, } } } }}) vim.lsp.config.clangd = { cmd = { 'clangd', '--clang-tidy', '--background-index', '--offset-encoding=utf-8', }, root_markers = { '.clangd', 'compile_commands.json' }, filetypes = { 'c', 'cpp' },}local cfg = vim.lsp.config.lua_ls{name},{enable})vim.lsp.enable()filetypes,root_markers, androot_dir fields.vim.lsp.enable('clangd')vim.lsp.enable({'lua_ls', 'pyright'})false stops and detaches the client(s). Thus you can "restart" LSP by disabling and re-enabling a given config:vim.lsp.enable('clangd', false)vim.lsp.enable('clangd', true)on_dir() only when you want that config to activate:vim.lsp.config('lua_ls', { root_dir = function(bufnr, on_dir) if not vim.fn.bufname(bufnr):match('%.txt$') then on_dir(vim.fn.getcwd()) end end}){name} (string|string[]) Name(s) of client(s) to enable.{enable} (boolean?)true|nil to enable,false to disable (actively stops and detaches clients as needed){kind},{winid})vim.lsp.foldclose(){kind} of folds in the the window with{winid}.vim.api.nvim_create_autocmd('LspNotify', { callback = function(args) if args.data.method == 'textDocument/didOpen' then vim.lsp.foldclose('imports', vim.fn.bufwinid(args.buf)) end end,}){kind} (lsp.FoldingRangeKind) Kind to close, one of "comment", "imports" or "region".{winid} (integer?) Defaults to the current window.{lnum})vim.lsp.foldexpr()foldexpr function.vim.o.foldmethod = 'expr'vim.o.foldexpr = 'v:lua.vim.lsp.foldexpr()'vim.o.foldmethod = 'expr'-- Default to treesitter foldingvim.o.foldexpr = 'v:lua.vim.treesitter.foldexpr()'-- Prefer LSP folding if client supports itvim.api.nvim_create_autocmd('LspAttach', { callback = function(args) local client = vim.lsp.get_client_by_id(args.data.client_id) if client:supports_method('textDocument/foldingRange') then local win = vim.api.nvim_get_current_win() vim.wo[win][0].foldexpr = 'v:lua.vim.lsp.foldexpr()' end end,}){lnum} (integer) line numberfoldtext function that shows thecollapsedText retrieved, defaults to the first folded line ifcollapsedText is not provided.{opts})vim.lsp.formatexpr()formatexpr function.setlocal formatexpr=v:lua.vim.lsp.formatexpr() or (more typically) inon_attach viavim.bo[bufnr].formatexpr = 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})'.{opts} (table?) A table with the following fields:{timeout_ms} (integer, default: 500ms) The timeout period for the formatting request..{client_id})vim.lsp.get_client_by_id(){client_id} (integer) client id{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{name})vim.lsp.is_enabled()vim.lsp.config['…'], this does not have the side-effect of resolving the config.{name} (string) Config nameboolean){findstart} (integer) 0 or 1, decides behavior{base} (integer) findstart=0, text to match againstinteger|table) Decided by{findstart}:{config},{opts})vim.lsp.start()name androot_dir. Attaches the current buffer to the client.vim.lsp.start({ name = 'my-server-name', cmd = {'name-of-language-server-executable'}, root_dir = vim.fs.root(0, {'pyproject.toml', 'setup.py'}),})name arbitrary name for the LSP client. Should be unique per language server.cmd command string[] or function.root_dir path to the project root. By default this is used to decide if an existing client should be re-used. The example above usesvim.fs.root() to detect the root by traversing the file system upwards starting from the current directory until either apyproject.toml orsetup.py file is found.workspace_folders list of{ uri:string, name: string } tables specifying the project root folders used by the language server. Ifnil the property is derived fromroot_dir for convenience.ftplugin/<filetype_name>.lua (Seeftplugin-name){opts} (table?) Optional keyword arguments.{reuse_client}? (fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig): boolean) Predicate used to decide if a client should be re-used. Used on all running clients. The default implementation re-uses a client if it has the same name and if the given workspace folders (or root_dir) are all included in the client's workspace folders.{bufnr}? (integer) Buffer handle to attach to if starting or re-using a client (0 for current).{attach}? (boolean) Whether to attach the client to a buffer (default true). If set tofalse,reuse_client andbufnr will be ignored.{silent}? (boolean) Suppress error reporting if the LSP server fails to start (default false).integer?) client_idstring){pattern},{flags})vim.lsp.tagfunc(){pattern} (string) Pattern used to find a workspace symboltable[]) tags A list of matching tagsvim.lsp.buf_… functions perform operations for LSP clients attached tothe current buffer.{on_list}? (fun(t: vim.lsp.LocationOpts.OnList)) list-handler replacing the default handler. Called for any non-empty result. This table can be used withsetqflist() orsetloclist(). E.g.:local function on_list(options) vim.fn.setqflist({}, ' ', options) vim.cmd.cfirst()endvim.lsp.buf.definition({ on_list = on_list })vim.lsp.buf.references(nil, { on_list = on_list }){loclist}? (boolean) Whether to use thelocation-list or thequickfix list in the default handler.vim.lsp.buf.definition({ loclist = true })vim.lsp.buf.references(nil, { loclist = false }){reuse_win}? (boolean) Jump to existing window if buffer is already open.{title}? (string) Title for the list.{silent}? (boolean){silent}? (boolean){workspace_folder}) Add the folder at path to the workspace folders. If{path} is not provided, the user will be prompted for a path usinginput().{workspace_folder} (string?){opts})vim.lsp.buf.code_action(){opts} (table?) A table with the following fields:{context}? (lsp.CodeActionContext) Corresponds toCodeActionContext of the LSP specification:{diagnostics}? (table) LSPDiagnostic[]. Inferred from the current position if not provided.{only}? (table) List of LSPCodeActionKinds used to filter the code actions. Most language servers support values likerefactor orquickfix.{triggerKind}? (integer) The reason why code actions were requested.{filter}? (fun(x: lsp.CodeAction|lsp.Command, client_id: integer):boolean) Predicate taking a code action or command and the provider's ID. If it returns false, the action is filtered out.{apply}? (boolean) When set totrue, 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 containstart andend keys with{row,col} tuples using mark-like indexing. Seeapi-indexing{opts})vim.lsp.buf.declaration()CursorHold, e.g.:autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight()autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references(){opts})vim.lsp.buf.document_symbol(){opts})vim.lsp.buf.format(){opts} (table?) A table with the following fields:{formatting_options}? (lsp.FormattingOptions) Can be used to specify FormattingOptions. Some unspecified options will be automatically derived from the current Nvim options. Seehttps://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 formattingvim.lsp.buf.format { filter = function(client) return client.name ~= "ts_ls" end}{async}? (boolean, default: false) If true the method won't block. Editing the buffer while formatting asynchronous can lead to unexpected changes.{id}? (integer) Restrict formatting to the client with ID (client.id) matching this field.{name}? (string) Restrict formatting to the client with name (client.name) matching this field.{range}? ({start:[integer,integer],end:[integer, integer]}|{start:[integer,integer],end:[integer,integer]}[], default: current selection in visual mode,nil in other modes, formatting the full buffer) Range to format. Table must containstart andend keys with{row,col} tuples using (1,0) indexing. Can also be a list of tables that containstart andend keys as described above, in which casetextDocument/rangesFormatting support is required.{config})vim.lsp.buf.hover()vim.api.nvim_create_autocmd('ColorScheme', { callback = function() vim.api.nvim_set_hl(0, 'LspReferenceTarget', {}) end,}){opts})vim.lsp.buf.implementation(){context},{opts})vim.lsp.buf.references(){context} (lsp.ReferenceContext?) Context for the request{workspace_folder}) Remove the folder at path from the workspace folders. If{path} is not provided, the user will be prompted for a path usinginput().{workspace_folder} (string?){new_name},{opts})vim.lsp.buf.rename(){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){direction},{timeout_ms}) Perform an incremental selection at the cursor position based on ranges given by the LSP. Thedirection parameter specifies the number of times to expand the selection. Negative values will shrink the selection.{direction} (integer){timeout_ms} (integer?) (default:1000) Maximum time (milliseconds) to wait for a result.{config})vim.lsp.buf.signature_help()<C-s>, which can be remapped via<Plug>(nvim.lsp.ctrl-s)vim.keymap.set('n', '<C-b>', '<Plug>(nvim.lsp.ctrl-s)'){opts})vim.lsp.buf.type_definition(){kind})vim.lsp.buf.typehierarchy(){kind} ("subtypes"|"supertypes"){opts})vim.lsp.buf.workspace_diagnostics(){opts} (table?) A table with the following fields:{client_id}? (integer) Only request diagnostics from the indicated client. If nil, the request is sent to all clients.{query},{opts})vim.lsp.buf.workspace_symbol(){query}; if the argument is omitted from the call, the user is prompted to enter a string on the command line. An empty string means no filtering is done.{attached_buffers} (table<integer,true>){capabilities} (lsp.ClientCapabilities) Capabilities provided by the client (editor or tool), at startup.{commands} (table<string,fun(command: lsp.Command, ctx: table)>) Client commands. Seevim.lsp.ClientConfig.{config} (vim.lsp.ClientConfig) Copy of the config passed tovim.lsp.start(). Seevim.lsp.ClientConfig.{dynamic_capabilities} (lsp.DynamicCapabilities) Capabilities provided at runtime (after startup).{flags} (table) A table with flags for the client. The current (experimental) flags are:{allow_incremental_sync}? (boolean, default:true) Allow using incremental sync for buffer edits{debounce_text_changes} (integer, default:150) DebouncedidChange notifications to the server by the given number in milliseconds. No debounce occurs ifnil.{exit_timeout} (integer|false, default:false) Milliseconds to wait for server to exit cleanly after sending the "shutdown" request before sending kill -15. If set to false, nvim exits immediately after sending the "shutdown" request to the server.{id} (integer) The id allocated to the client.{initialized} (true?){progress} (vim.lsp.Client.Progress) A ring buffer (vim.ringbuf()) containing progress messages sent by the server. Seevim.lsp.Client.Progress.{requests} (table<integer,{ type: string, bufnr: integer, method: string}?>) The current pending requests in flight to the server. Entries are key-value pairs with the key being the request id while the value is a table withtype,bufnr, andmethod key-value pairs.type is either "pending" for an active request, or "cancel" for a cancel request. It will be "complete" ephemerally while executingLspRequest autocmds when replies are received from the server.{rpc} (vim.lsp.rpc.PublicClient) RPC client object, for low level interaction with the client. Seevim.lsp.rpc.start().{server_capabilities} (lsp.ServerCapabilities?) Response from the server sent oninitialize describing the server's capabilities.{server_info} (lsp.ServerInfo?) Response from the server sent oninitialize describing server information (e.g. version).{request} (fun(self: vim.lsp.Client, method: string, params: table?, handler: lsp.Handler?, bufnr: integer?): boolean, integer?) SeeClient:request().{request_sync} (fun(self: vim.lsp.Client, method: string, params: table, timeout_ms: integer?, bufnr: integer?): {err: lsp.ResponseError?, result:any}?, string?) SeeClient:request_sync().{exec_cmd} (fun(self: vim.lsp.Client, command: lsp.Command, context: {bufnr?: integer}?, handler: lsp.Handler?)) SeeClient:exec_cmd().{supports_method} (fun(self: vim.lsp.Client, method: string, bufnr: integer?)) SeeClient:supports_method().{pending} (table<lsp.ProgressToken,lsp.LSPAny>){before_init}? (fun(params: lsp.InitializeParams, config: vim.lsp.ClientConfig)) Callback which can modify parameters before they are sent to the server. Invoked before LSP "initialize" phase (aftercmd is invoked), whereparams is the parameters being sent to the server andconfig is the config passed tovim.lsp.start().{capabilities}? (lsp.ClientCapabilities) Map overriding the default capabilities defined byvim.lsp.protocol.make_client_capabilities(), passed to the language server on initialization. Hint: use make_client_capabilities() and modify its result.{cmd} (string[]|fun(dispatchers: vim.lsp.rpc.Dispatchers, config: vim.lsp.ClientConfig): vim.lsp.rpc.PublicClient) Commandstring[] that launches the language server (treated as injobstart(), must be absolute or on$PATH, shell constructs like "~" are not expanded), or function that creates an RPC client. Function receives adispatchers table and the resolvedconfig, and must return a table with member functionsrequest,notify,is_closing andterminate. Seevim.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 thecmd process. Not related toroot_dir.{cmd_env}? (table) Environment variables passed to the LSP process on spawn. Non-string values are coerced to string. Example:{ PORT = 8080; HOST = '0.0.0.0'; }{commands}? (table<string,fun(command: lsp.Command, ctx: table)>) Map of client-defined commands overriding the globalvim.lsp.commands.{detached}? (boolean, default:true) Daemonize the server process so that it runs in a separate process group from Nvim. Nvim will shutdown the process on exit, but if Nvim fails to exit cleanly this could leave behind orphaned server processes.{flags}? (table) A table with flags for the client. The current (experimental) flags are:{allow_incremental_sync}? (boolean, default:true) Allow using incremental sync for buffer edits{debounce_text_changes} (integer, default:150) DebouncedidChange notifications to the server by the given number in milliseconds. No debounce occurs ifnil.{exit_timeout} (integer|false, default:false) Milliseconds to wait for server to exit cleanly after sending the "shutdown" request before sending kill -15. If set to false, nvim exits immediately after sending the "shutdown" request to the server.{get_language_id}? (fun(bufnr: integer, filetype: string): string) Language ID as string. Defaults to the buffer filetype.{init_options}? (lsp.LSPObject) Values to pass in the initialization request asinitializationOptions. Seeinitialize in the LSP spec.{name}? (string, default: client-id) Name in logs and user messages.{offset_encoding}? ('utf-8'|'utf-16'|'utf-32') Called "position encoding" in LSP spec. The encoding that the LSP server expects, used for communication. Not validated. Can be modified inon_init before text is sent to the server.{on_attach}? (elem_or_list<fun(client: vim.lsp.Client, bufnr: integer)>) Callback invoked when client attaches to a buffer.{on_error}? (fun(code: integer, err: string)) Callback invoked when the client operation throws an error.code is a number describing the error. Other arguments may be passed depending on the error kind. Seevim.lsp.rpc.client_errors for possible errors. Usevim.lsp.rpc.client_errors[code] to get human-friendly name.{on_exit}? (elem_or_list<fun(code: integer, signal: integer, client_id: integer)>) Callback invoked on client exit.{on_init}? (elem_or_list<fun(client: vim.lsp.Client, init_result: lsp.InitializeResult)>) Callback invoked after LSP "initialize", whereresult is a table ofcapabilities and anything else the server may send. For example, clangd sendsinit_result.offsetEncoding ifcapabilities.offsetEncoding was sent to it. You can only modify theclient.offset_encoding here before any notifications are sent.{root_dir}? (string) Directory where the LSP server will base its workspaceFolders, rootUri, and rootPath on initialization.{settings}? (lsp.LSPObject) Map of language server-specific settings, decided by the client. Sent to the LS if requested viaworkspace/configuration. Keys are case-sensitive.{trace}? ('off'|'messages'|'verbose', default: "off") Passed directly to the language server in the initialize request. Invalid/empty values will{workspace_folders}? (lsp.WorkspaceFolder[]) List of workspace folders passed to the language server. For backwards compatibility rootUri and rootPath are derived from the first workspace folder in this list. Can benull if the client supports workspace folders but none are configured. SeeworkspaceFolders in LSP spec.{workspace_required}? (boolean, default:false) Server requires a workspace (no "single file" support). Note: Without a workspace, cross-file features (navigation, hover) may or may not work depending on the language server, even if the server doesn't require a workspace.{id} (integer) id of request to cancelboolean) status indicating if the notification was successful.{command},{context},{handler})Client:exec_cmd(){command} (lsp.Command){context} ({bufnr?: integer}?){handler} (lsp.Handler?) only called if a server commandboolean) true if client is stopped or in the process of being stopped; false otherwise{method} (string) LSP method name.{params} (table?) LSP request params.boolean) status indicating if the notification was successful. If it is false, then the client has shutdown.{bufnr})Client:on_attach(){bufnr} (integer) Buffer number{client.rpc.request} with some additional checks for capabilities and handler availability.{method} (string) LSP method name.{params} (table?) LSP request params.{bufnr} (integer?) (default: 0) Buffer handle, or 0 for current.boolean) status indicates whether the request was successful. If it isfalse, then it will always befalse (the client has shutdown). (integer?) request_id Can be used withClient:cancel_request().nil is request failed.{method},{params},{timeout_ms},{bufnr}) Sends a request to the server and synchronously waits for the response.{method} (string) LSP method name.{params} (table) LSP request params.{timeout_ms} (integer?) Maximum time in milliseconds to wait for a result. Defaults to 1000{bufnr} (integer?) (default: 0) Buffer handle, or 0 for current.{err: lsp.ResponseError?, result:any}?)result anderr from thelsp-handler.nil is the request was unsuccessful (string?) err On timeout, cancel or error, whereerr is a string describing the failure reason.force is a number, it will be treated as the time in milliseconds to wait before forcing the shutdown.{force} (boolean|integer?){method},{bufnr})Client:supports_method(){method} (string){bufnr} (integer?){client_id} (integer?) filter by client_id. All clients if nil{bufnr} (integer?) filter by buffer. All buffers if nil, 0 for current buffer{lenses},{bufnr},{client_id})vim.lsp.codelens.display(){lenses} (lsp.CodeLens[]?) lenses to display{bufnr} (integer){client_id} (integer){bufnr} (integer) Buffer number. 0 can be used for the current buffer.lsp.CodeLens[]){err},{result},{ctx})vim.lsp.codelens.on_codelens()textDocument/codeLens{err} (lsp.ResponseError?){result} (lsp.CodeLens[]){ctx} (lsp.HandlerContext)autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh({ bufnr = 0 }){opts} (table?) Optional fields{bufnr} (integer?) filter by buffer. All buffers if nil, 0 for current buffer{lenses},{bufnr},{client_id})vim.lsp.codelens.save(){lenses} (lsp.CodeLens[]?) lenses to store{bufnr} (integer){client_id} (integer)vim.lsp.completion module enables insert-mode completion driven by anLSP server. Callenable() to make it available through Nvim builtincompletion (via theCompleteDone event). Specifyautotrigger=true toactivate "auto-completion" when you type any of the server-definedtriggerCharacters. UseCTRL-Y to select an item from the completion menu.complete_CTRL-Y-- Works best with completeopt=noselect.-- Use CTRL-Y to select an item. |complete_CTRL-Y|vim.cmd[[set completeopt+=menuone,noselect,popup]]vim.lsp.start({ name = 'ts_ls', cmd = …, on_attach = function(client, bufnr) vim.lsp.completion.enable(true, client.id, bufnr, { autotrigger = true, convert = function(item) return { abbr = item.label:gsub('%b()', '') } end, }) end,})triggerCharacters field decides when to trigger autocompletion. Ifyou want to trigger on EVERY keypress you can either:client.server_capabilities.completionProvider.triggerCharacters onLspAttach, before you callvim.lsp.completion.enable(… {autotrigger=true}). See thelsp-attach example.vim.lsp.completion.get() from anInsertCharPre autocommand.{enable},{client_id},{bufnr},{opts}) Enables or disables completions from the given language client in the given buffer. Effects of enabling completions are:<c-y> applies side effects like expanding snippets, text edits (e.g. insert import statements) and executing associated commands. This works for completions triggered via autotrigger, omnifunc or completion.get()autotrigger=true is controlled by the LSPtriggerCharacters field. You can override it on LspAttach, seelsp-autocompletion.{enable} (boolean) True to enable, false to disable{client_id} (integer) Client ID{bufnr} (integer) Buffer handle, or 0 for the current buffer{opts} (table?) A table with the following fields:{autotrigger}? (boolean) (default: false) When true, completion triggers automatically based on the server'striggerCharacters.{convert}? (fun(item: lsp.CompletionItem): table) Transforms an LSP CompletionItem tocomplete-items.{cmp}? (fun(a: table, b: table): boolean) Comparator for sorting merged completion items from all servers.{opts})vim.lsp.completion.get()CTRL-Y to select an item from the completion menu.complete_CTRL-YCTRL-space, use this mapping:-- Use CTRL-space to trigger LSP completion.-- Use CTRL-Y to select an item. |complete_CTRL-Y|vim.keymap.set('i', '<c-space>', function() vim.lsp.completion.get()end){opts} (table?) A table with the following fields:{ctx}? (lsp.CompletionContext) Completion context. Defaults to a trigger kind ofinvoked.DiagnosticRelatedInformation is supported: it is included in the windowshown byvim.diagnostic.open_float(). When the cursor is on a line withrelated information,gf jumps to the problem location.{diagnostics} (vim.Diagnostic[])lsp.Diagnostic[]){client_id},{is_pull}) Get the diagnostic namespace associated with an LSP clientvim.diagnostic for diagnostics{client_id} (integer) The id of the LSP client{is_pull} (boolean?) Whether the namespace is for a pull or push client. Defaults to push{error},{result},{ctx})lsp-handler for the method "textDocument/diagnostic"{error} (lsp.ResponseError?){result} (lsp.DocumentDiagnosticReport){ctx} (lsp.HandlerContext){_},{params},{ctx})lsp-handler for the method "textDocument/publishDiagnostics"{params} (lsp.PublishDiagnosticsParams){ctx} (lsp.HandlerContext){enable},{bufnr},{opts})vim.lsp.document_color.enable()is_enabled():vim.lsp.document_color.enable(not vim.lsp.document_color.is_enabled()){enable} (boolean?) True to enable, false to disable. (default:true){bufnr} (integer?) Buffer handle, or 0 for current. (default: 0){opts} (table?) A table with the following fields:{style}? ('background'|'foreground'|'virtual'|string|fun(bufnr: integer, range: Range4, hex_code: string)) Highlight style. It can be one of the pre-defined styles, a string to be used as virtual text, or a function that receives the buffer handle, the range (start line, start col, end line, end col) and the resolved hex color. (default:'background'){bufnr})vim.lsp.document_color.is_enabled(){bufnr} (integer?) Buffer handle, or 0 for current. (default: 0)boolean){enable},{filter})vim.lsp.inlay_hint.enable(){filter}ed scope.is_enabled():vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled()){enable} (boolean?) true/nil to enable, false to disable{bufnr} (integer?) Buffer number, or 0 for current buffer, or nil for all.{filter})vim.lsp.inlay_hint.get()local hint = vim.lsp.inlay_hint.get({ bufnr = 0 })[1] -- 0 for current bufferlocal 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].locationclient:request('textDocument/hover', { textDocument = { uri = location.uri }, position = location.range.start,})table[]) A list of objects with the following fields:{bufnr} (integer){client_id} (integer){inlay_hint} (lsp.InlayHint){filter})vim.lsp.inlay_hint.is_enabled(){filter}ed scope{bufnr} (integer?) Buffer number, or 0 for current buffer, or nil for all.boolean)npm install --global @github/copilot-language-serverlsp/copilot.lua fromhttps://github.com/neovim/nvim-lspconfig): vim.lsp.config('copilot', { cmd = { 'copilot-language-server', '--stdio', }, root_markers = { '.git' },})vim.lsp.enable('copilot'):LspCopilotSignIn command fromhttps://github.com/neovim/nvim-lspconfigvim.lsp.inline_completion.enable()vim.lsp.inline_completion.get() and invoke the keymap.{client_id} (integer) Client ID{insert_text} (string|lsp.StringValue) The text to be inserted, can be a snippet.{range}? (vim.Range) Which range it be applied.{command}? (lsp.Command) Corresponding server command.{enable},{filter})vim.lsp.inline_completion.enable(){filter}ed scope, inline completion will automatically be refreshed when you are in insert mode.is_enabled():vim.lsp.inline_completion.enable(not vim.lsp.inline_completion.is_enabled()){enable} (boolean?) true/nil to enable, false to disable{bufnr}? (integer, default: all) Buffer number, or 0 for current buffer, or nil for all.{client_id}? (integer, default: all) Client ID, or nil for all.{opts})vim.lsp.inline_completion.get() vim.keymap.set('i', '<Tab>', function() if not vim.lsp.inline_completion.get() then return '<Tab>' endend, { expr = true, desc = 'Accept the current inline completion' }){opts} (table?) A table with the following fields:{bufnr}? (integer, default: 0) Buffer handle, or 0 for current.{on_accept}? (fun(item: vim.lsp.inline_completion.Item)) Accept handler, called with the accepted item. If not provided, the default handler is used, which applies changes to the buffer based on the completion item.boolean)true if a completion was applied, elsefalse.{filter})vim.lsp.inline_completion.is_enabled(){filter}ed scope{bufnr}? (integer, default: all) Buffer number, or 0 for current buffer, or nil for all.{client_id}? (integer, default: all) Client ID, or nil for all.{opts})vim.lsp.inline_completion.select(){opts} (table?) A table with the following fields:{bufnr}? (integer) (default: current buffer){count}? (integer, default: v:count1) The number of candidates to move by. A positive integer moves forward by{count} candidates, while a negative integer moves backward by{count} candidates.vim.lsp.linked_editing_range module enables "linked editing" via alanguage server'stextDocument/linkedEditingRange request. Linked editingranges are synchronized text regions, meaning changes in one range aremirrored in all the others. This is helpful in HTML files for example, wherethe language server can update the text of a closing tag if its opening tagwas changed.{enable},{filter})vim.lsp.linked_editing_range.enable()vim.lsp.start({ name = 'html', cmd = '…', on_attach = function(client) vim.lsp.linked_editing_range.enable(true, { client_id = client.id }) end,}){enable} (boolean?)true ornil to enable,false to disable.{client_id} (integer?) Client ID, ornil for all.vim.lsp.log module provides logging for the Nvim LSP client.vim.lsp.log.set_level 'trace'require('vim.lsp.log').set_format_func(vim.inspect):lua vim.cmd('tabnew ' .. vim.lsp.log.get_filename()):LspLog if you have nvim-lspconfig installed.)string) log filenameinteger) current log level{handle})vim.lsp.log.set_format_func(){handle} (fun(level:string, ...): string?) Function to apply to log entries. The default will log the level, date, source and line number of the caller, followed by the arguments.{enable},{filter})vim.lsp.on_type_formatting.enable(){filter}ed scope. The following are some practical usage examples:-- Enable for all clientsvim.lsp.on_type_formatting.enable()-- Enable for a specific clientvim.api.nvim_create_autocmd('LspAttach', { callback = function(args) local client_id = args.data.client_id local client = assert(vim.lsp.get_client_by_id(client_id)) if client.name == 'rust-analyzer' then vim.lsp.on_type_formatting.enable(true, { client_id = client_id }) end end,}){enable} (boolean?) true/nil to enable, false to disable.{client_id} (integer?) Client ID, ornil for all.{request} (fun(method: string, params: table?, callback: fun(err?: lsp.ResponseError, result: any), notify_reply_callback?: fun(message_id: integer)):boolean,integer?) Seevim.lsp.rpc.request(){is_closing} (fun(): boolean) Indicates if the RPC is closing.{terminate} (fun()) Terminates the RPC client.{host_or_path},{port})vim.lsp.rpc.connect()cmd field forvim.lsp.start().{host_or_path} (string) host to connect to or path to a pipe/domain socket{port} (integer?) TCP port to connect to. If absent the first argument must be a pipefun(dispatchers: vim.lsp.rpc.Dispatchers): vim.lsp.rpc.PublicClient){err})vim.lsp.rpc.format_rpc_error(){err} (table) The error objectstring) error_message The formatted error message{method} (string) The invoked LSP method{params} (table?) Parameters for the invoked LSP methodboolean)true if notification could be sent,false if not{method},{params},{callback},{notify_reply_callback}) Sends a request to the LSP server and runs{callback} upon response.{method} (string) The invoked LSP method{params} (table?) Parameters for the invoked LSP method{callback} (fun(err: lsp.ResponseError?, result: any)) Callback to invoke{notify_reply_callback} (fun(message_id: integer)?) Callback to invoke as soon as a request is no longer pendingboolean) successtrue if request could be sent,false if not (integer?) message_id if request could be sent,nil if not{code},{message},{data}) Creates an RPC response tableerror to be sent to the LSP response.{code} (integer) RPC error code defined, seevim.lsp.protocol.ErrorCodes{message} (string?) arbitrary message to send to server{data} (any?) arbitrary data to send to serverlsp.ResponseError)vim.lsp.protocol.ErrorCodes{cmd},{dispatchers},{extra_spawn_params})vim.lsp.rpc.start() Starts an LSP server process and create an LSP RPC client object to interact with it. Communication with the spawned process happens via stdio. For communication via TCP, spawn a process manually and usevim.lsp.rpc.connect(){cmd} (string[]) Command to start the LSP server.{dispatchers} (table?) Dispatchers for LSP message types.{notification} (fun(method: string, params: table)){server_request} (fun(method: string, params: table): any?, lsp.ResponseError?){on_exit} (fun(code: integer, signal: integer)){on_error} (fun(code: integer, err: any)){extra_spawn_params} (table?) Additional context for the LSP server process.{cwd}? (string) Working directory for the LSP server process{detached}? (boolean) Detach the LSP server process from the current process{env}? (table<string,string>) Additional environment variables for LSP server process. Seevim.system(){enable},{filter})vim.lsp.semantic_tokens.enable(){filter}ed scope.is_enabled():vim.lsp.semantic_tokens.enable(not vim.lsp.semantic_tokens.is_enabled()){enable} (boolean?) true/nil to enable, false to disable{bufnr}? (integer, default: all) Buffer number, or 0 for current buffer, or nil for all.{client_id}? (integer, default: all) Client ID, or nil for all.{bufnr})vim.lsp.semantic_tokens.force_refresh(){bufnr} (integer?) filter by buffer. All buffers if nil, current buffer if 0{bufnr},{row},{col}) Return the semantic token(s) at the given position. If called without arguments, returns the token under the cursor.{bufnr} (integer?) Buffer number (0 for current buffer, default){row} (integer?) Position row (default cursor position){col} (integer?) Position column (default cursor position)table?) List of tokens at position. Each token has the following fields:{token},{bufnr},{client_id},{hl_group},{opts}) Highlight a semantic token.{bufnr} (integer) The buffer to highlight, or0 for current buffer{hl_group} (string) Highlight group name{opts} (table?) Optional parameters:{priority}? (integer, default:vim.hl.priorities.semantic_tokens + 3) Priority for the applied extmark.{filter})vim.lsp.semantic_tokens.is_enabled(){filter}ed scope{bufnr}? (integer, default: all) Buffer number, or 0 for current buffer, or nil for all.{client_id}? (integer, default: all) Client ID, or nil for all.{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) Iftrue, and if{focusable} is alsotrue, focus an existing floating window with the same{focus_id}{offset_x}? (integer) offset to add tocol{offset_y}? (integer) offset to add torow{border}? (string|(string|[string,string])[]) overrideborder{zindex}? (integer) overridezindex, defaults to 50{title}? (string|[string,string][]){title_pos}? ('left'|'center'|'right'){relative}? ('mouse'|'cursor'|'editor') (default:'cursor'){anchor_bias}? ('auto'|'above'|'below', default:'auto') Adjusts placement relative to cursor.{text_document_edit},{index},{position_encoding},{change_annotations}) Applies aTextDocumentEdit, which is a list of changes to a single document.{text_document_edit} (lsp.TextDocumentEdit){index} (integer?) Optional index of the edit, if from a list of edits (or nil, if not from a list){position_encoding} ('utf-8'|'utf-16'|'utf-32'?){change_annotations} (table<string, lsp.ChangeAnnotation>?){text_edits},{bufnr},{position_encoding},{change_annotations}) Applies a list of text edits to a buffer.{text_edits} ((lsp.TextEdit|lsp.AnnotatedTextEdit)[]){bufnr} (integer) Buffer id{position_encoding} ('utf-8'|'utf-16'|'utf-32'){change_annotations} (table<string, lsp.ChangeAnnotation>?){workspace_edit},{position_encoding}) Applies aWorkspaceEdit.{workspace_edit} (lsp.WorkspaceEdit){position_encoding} ('utf-8'|'utf-16'|'utf-32') (required){bufnr})vim.lsp.util.buf_clear_references(){bufnr} (integer?) Buffer id{bufnr},{references},{position_encoding}) Shows a list of document highlights for a certain buffer.{bufnr} (integer) Buffer id{references} (lsp.DocumentHighlight[]) objects to highlight{position_encoding} ('utf-8'|'utf-16'|'utf-32'){buf},{row},{col},{offset_encoding}) Returns the UTF-32 and UTF-16 offsets for a position in a certain buffer.{buf} (integer) buffer number (0 for current){row} (integer) 0-indexed line{col} (integer) 0-indexed byte offset in line{offset_encoding} ('utf-8'|'utf-16'|'utf-32'?) defaults tooffset_encoding of first client ofbufinteger)offset_encoding index of the character in line{row} column{col} in buffer{buf}{input},{contents}) Converts any ofMarkedString |MarkedString[] |MarkupContent into a list of lines containing valid markdown. Useful to populate the hover window fortextDocument/hover, for parsing the result oftextDocument/signatureHelp, and potentially others.MarkupContent and its kind isplaintext, then the corresponding value is returned without further modifications.{input} (lsp.MarkedString|lsp.MarkedString[]|lsp.MarkupContent){contents} (string[]?) List of strings to extend with converted lines. Defaults to {}.string[]) extended with lines of converted markdown.{signature_help},{ft},{triggers}) ConvertstextDocument/signatureHelp response to markdown lines.{signature_help} (lsp.SignatureHelp) Response oftextDocument/SignatureHelp{ft} (string?) filetype that will be use as thelang for the label markdown code block{triggers} (string[]?) list of trigger characters from the lsp server. used to better determine parameter offsetsstring[]?) lines of converted markdown. (Range4?) highlight range for the active parameter{bufnr} (integer?) Buffer handle, defaults to currentinteger) indentation size{locations},{position_encoding}) Returns the items with the byte position calculated correctly and in sorted order, for display in quickfix and location lists.user_data field of each resulting item will contain the originalLocation orLocationLink it was computed from.{locations} (lsp.Location[]|lsp.LocationLink[]){position_encoding} ('utf-8'|'utf-16'|'utf-32'?) default to first client of buffer{width},{height},{opts}) Creates a table with sensible default options for a floating window. The table can be passed tonvim_open_win().{width} (integer) window width (in character cells){height} (integer) window height (in character cells)vim.api.keyset.win_config){options}) Creates aDocumentFormattingParams object for the current buffer and cursor position.{options} (lsp.FormattingOptions?) with validFormattingOptions entrieslsp.DocumentFormattingParams) object{start_pos},{end_pos},{bufnr},{position_encoding}) Using the given range in the current buffer, creates an object that is similar tovim.lsp.util.make_range_params().{start_pos} ([integer,integer]?){row,col} mark-indexed position. Defaults to the start of the last visual selection.{end_pos} ([integer,integer]?){row,col} mark-indexed position. Defaults to the end of the last visual selection.{bufnr} (integer?) buffer handle or 0 for current, defaults to current{position_encoding} ('utf-8'|'utf-16'|'utf-32'){ textDocument: { uri: lsp.DocumentUri }, range: lsp.Range }){window},{position_encoding}) Creates aTextDocumentPositionParams object for the current buffer and cursor position.{position_encoding} ('utf-8'|'utf-16'|'utf-32')lsp.TextDocumentPositionParams){window},{position_encoding}) Using the current position in the current buffer, creates an object that can be used as a building block for several LSP requests, such astextDocument/codeAction,textDocument/colorPresentation,textDocument/rangeFormatting.{position_encoding} ("utf-8"|"utf-16"|"utf-32"){ textDocument: { uri: lsp.DocumentUri }, range: lsp.Range }){bufnr}) Creates aTextDocumentIdentifier object for the current buffer.{bufnr} (integer?) Buffer handle, defaults to currentlsp.TextDocumentIdentifier){added},{removed}) Create the workspace params{added} (lsp.WorkspaceFolder[]){removed} (lsp.WorkspaceFolder[])lsp.DidChangeWorkspaceFoldersParams){contents},{syntax},{opts}) Shows contents in a floating window.{contents} (table) of lines to show in window{syntax} (string) of syntax to set for opened buffer{opts} (vim.lsp.util.open_floating_preview.Opts?) with optional fields (additional keys are filtered withvim.lsp.util.make_floating_popup_options() before they are passed on tonvim_open_win()). Seevim.lsp.util.open_floating_preview.Opts.integer) bufnr of newly created float window (integer) winid of newly created float window preview window{location},{opts})vim.lsp.util.preview_location(){location} (lsp.Location|lsp.LocationLink)integer?) buffer id of float window (integer?) window id of float windowopts requests overwriting; or{old_fname} (string){new_fname} (string){opts} (table?) Options:{overwrite}? (boolean){ignoreIfExists}? (boolean){location},{position_encoding},{opts}) Shows document and optionally jumps to the location.{location} (lsp.Location|lsp.LocationLink){position_encoding} ('utf-8'|'utf-16'|'utf-32'?){opts} (table?) A table with the following fields:{reuse_win}? (boolean) Jump to existing window if buffer is already open.{focus}? (boolean) Whether to focus/jump to location if possible. (defaults: true)boolean)true if succeeded{symbols},{bufnr},{position_encoding}) Converts symbols to quickfix list items.{symbols} (lsp.DocumentSymbol[]|lsp.SymbolInformation[]|lsp.WorkspaceSymbol[]) list of symbols{bufnr} (integer?) buffer handle or 0 for current, defaults to current{position_encoding} ('utf-8'|'utf-16'|'utf-32'?) default to first client of bufferlsp.ClientCapabilities){server_capabilities}) Creates a normalized object describing LSP server capabilities.{server_capabilities} (table) Table of capabilities supported by the serverlsp.ServerCapabilities?) Normalized table of capabilities