From 97bea3163a3fe50359e7f6ffda747e28974a818a Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Wed, 13 Dec 2023 12:00:11 +0000
Subject: feat(lsp): more annotations

---
 runtime/lua/vim/lsp.lua | 114 ++++++++++++++++++++++++++++--------------------
 1 file changed, 67 insertions(+), 47 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 261a3aa5de..31aacd668b 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -257,7 +257,7 @@ end
 --- Validates a client configuration as given to |vim.lsp.start_client()|.
 ---
 ---@param config (lsp.ClientConfig)
----@return (string|fun(dispatchers:table):table) Command
+---@return (string|fun(dispatchers:vim.rpc.Dispatchers):RpcClientPublic?) Command
 ---@return string[] Arguments
 ---@return string Encoding.
 local function validate_client_config(config)
@@ -290,7 +290,7 @@ local function validate_client_config(config)
     'flags.debounce_text_changes must be a number with the debounce time in milliseconds'
   )
 
-  local cmd, cmd_args --- @type (string|fun(dispatchers:table):table), string[]
+  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.rpc.Dispatchers):RpcClientPublic), string[]
   local config_cmd = config.cmd
   if type(config_cmd) == 'function' then
     cmd = config_cmd
@@ -397,13 +397,14 @@ do
     end,
   })
 
+  ---@param client lsp.Client
   ---@return CTGroup
   local function get_group(client)
     local allow_inc_sync = if_nil(client.config.flags.allow_incremental_sync, true)
     local change_capability = vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'change')
     local sync_kind = change_capability or protocol.TextDocumentSyncKind.None
     if not allow_inc_sync and change_capability == protocol.TextDocumentSyncKind.Incremental then
-      sync_kind = protocol.TextDocumentSyncKind.Full
+      sync_kind = protocol.TextDocumentSyncKind.Full --[[@as integer]]
     end
     return {
       sync_kind = sync_kind,
@@ -572,7 +573,7 @@ do
       return
     end
 
-    local changes
+    local changes --- @type lsp.TextDocumentContentChangeEvent[]
     if sync_kind == protocol.TextDocumentSyncKind.None then
       return
     elseif sync_kind == protocol.TextDocumentSyncKind.Incremental then
@@ -650,6 +651,7 @@ do
   end
 
   ---@private
+  ---@param buf_state CTBufferState
   function changetracking._reset_timer(buf_state)
     local timer = buf_state.timer
     if timer then
@@ -663,6 +665,8 @@ do
 
   --- Flushes any outstanding change notification.
   ---@private
+  ---@param client lsp.Client
+  ---@param bufnr? integer
   function changetracking.flush(client, bufnr)
     local group = get_group(client)
     local state = state_by_group[group]
@@ -685,7 +689,7 @@ end
 --- Default handler for the 'textDocument/didOpen' LSP notification.
 ---
 ---@param bufnr integer Number of the buffer, or 0 for current
----@param client table Client object
+---@param client lsp.Client Client object
 local function text_document_did_open_handler(bufnr, client)
   changetracking.init(client, bufnr)
   if not vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'openClose') then
@@ -890,7 +894,7 @@ end
 ---@return string
 function lsp.status()
   local percentage = nil
-  local messages = {}
+  local messages = {} --- @type string[]
   for _, client in ipairs(vim.lsp.get_clients()) do
     for progress in client.progress do
       local value = progress.value
@@ -913,12 +917,15 @@ function lsp.status()
 end
 
 -- Determines whether the given option can be set by `set_defaults`.
+---@param bufnr integer
+---@param option string
+---@return boolean
 local function is_empty_or_default(bufnr, option)
   if vim.bo[bufnr][option] == '' then
     return true
   end
 
-  local info = vim.api.nvim_get_option_info2(option, { buf = bufnr })
+  local info = api.nvim_get_option_info2(option, { buf = bufnr })
   local scriptinfo = vim.tbl_filter(function(e)
     return e.sid == info.last_set_sid
   end, vim.fn.getscriptinfo())
@@ -932,6 +939,7 @@ end
 
 ---@private
 ---@param client lsp.Client
+---@param bufnr integer
 function lsp._set_defaults(client, bufnr)
   if
     client.supports_method(ms.textDocument_definition) and is_empty_or_default(bufnr, 'tagfunc')
@@ -1131,7 +1139,7 @@ function lsp.start_client(config)
   --- Returns the default handler if the user hasn't set a custom one.
   ---
   ---@param method (string) LSP method name
-  ---@return lsp-handler|nil The handler for the given method, if defined, or the default from |vim.lsp.handlers|
+  ---@return lsp.Handler|nil handler for the given method, if defined, or the default from |vim.lsp.handlers|
   local function resolve_handler(method)
     return handlers[method] or default_handlers[method]
   end
@@ -1189,7 +1197,7 @@ function lsp.start_client(config)
   --- Invoked when the client operation throws an error.
   ---
   ---@param code (integer) Error code
-  ---@param err (...) Other arguments may be passed depending on the error kind
+  ---@param err any 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 a human-friendly name.
   function dispatch.on_error(code, err)
@@ -1197,7 +1205,9 @@ function lsp.start_client(config)
     if config.on_error then
       local status, usererr = pcall(config.on_error, code, err)
       if not status then
-        local _ = log.error() and log.error(log_prefix, 'user on_error failed', { err = usererr })
+        if log.error() then
+          log.error(log_prefix, 'user on_error failed', { err = usererr })
+        end
         err_message(log_prefix, ' user on_error failed: ', tostring(usererr))
       end
     end
@@ -1283,7 +1293,7 @@ function lsp.start_client(config)
   end
 
   -- Start the RPC client.
-  local rpc
+  local rpc --- @type RpcClientPublic?
   if type(cmd) == 'function' then
     rpc = cmd(dispatch)
   else
@@ -1306,9 +1316,10 @@ function lsp.start_client(config)
     rpc = rpc,
     offset_encoding = offset_encoding,
     config = config,
-    attached_buffers = {},
+    attached_buffers = {}, --- @type table<integer,true>
 
     handlers = handlers,
+    --- @type table<string,function>
     commands = config.commands or {},
 
     --- @type table<integer,{ type: string, bufnr: integer, method: string}>
@@ -1346,7 +1357,7 @@ function lsp.start_client(config)
       verbose = 'verbose',
     }
 
-    local workspace_folders --- @type table[]?
+    local workspace_folders --- @type lsp.WorkspaceFolder[]?
     local root_uri --- @type string?
     local root_path --- @type string?
     if config.workspace_folders or config.root_dir then
@@ -1426,7 +1437,9 @@ function lsp.start_client(config)
       end
     end
 
-    local _ = log.trace() and log.trace(log_prefix, 'initialize_params', initialize_params)
+    if log.trace() then
+      log.trace(log_prefix, 'initialize_params', initialize_params)
+    end
     rpc.request('initialize', initialize_params, function(init_err, result)
       assert(not init_err, tostring(init_err))
       assert(result, 'server sent empty result')
@@ -1439,7 +1452,7 @@ function lsp.start_client(config)
       -- when to send certain events to clients.
       client.server_capabilities =
         assert(result.capabilities, "initialize result doesn't contain capabilities")
-      client.server_capabilities = protocol.resolve_capabilities(client.server_capabilities)
+      client.server_capabilities = assert(protocol.resolve_capabilities(client.server_capabilities))
 
       if client.server_capabilities.positionEncoding then
         client.offset_encoding = client.server_capabilities.positionEncoding
@@ -1455,12 +1468,13 @@ function lsp.start_client(config)
           write_error(lsp.client_errors.ON_INIT_CALLBACK_ERROR, err)
         end
       end
-      local _ = log.info()
-        and log.info(
+      if log.info() then
+        log.info(
           log_prefix,
           'server_capabilities',
           { server_capabilities = client.server_capabilities }
         )
+      end
 
       -- Only assign after initialized.
       active_clients[client_id] = client
@@ -1483,7 +1497,7 @@ function lsp.start_client(config)
   ---
   ---@param method string LSP method name.
   ---@param params table|nil LSP request params.
-  ---@param handler lsp-handler|nil Response |lsp-handler| for this method.
+  ---@param handler lsp.Handler|nil Response |lsp-handler| for this method.
   ---@param bufnr integer Buffer handle (0 for current).
   ---@return boolean status, integer|nil request_id {status} is a bool indicating
   ---whether the request was successful. If it is `false`, then it will
@@ -1677,9 +1691,9 @@ function lsp.start_client(config)
   ---
   ---@param command lsp.Command
   ---@param context? {bufnr: integer}
-  ---@param handler? lsp-handler only called if a server command
+  ---@param handler? lsp.Handler only called if a server command
   function client._exec_cmd(command, context, handler)
-    context = vim.deepcopy(context or {})
+    context = vim.deepcopy(context or {}) --[[@as lsp.HandlerContext]]
     context.bufnr = context.bufnr or api.nvim_get_current_buf()
     context.client_id = client.id
     local cmdname = command.command
@@ -1749,29 +1763,32 @@ function lsp.start_client(config)
   return client_id
 end
 
----@private
----@fn text_document_did_change_handler(_, bufnr, changedtick, firstline, lastline, new_lastline, old_byte_size, old_utf32_size, old_utf16_size)
 --- Notify all attached clients that a buffer has changed.
-local text_document_did_change_handler
-do
-  text_document_did_change_handler = function(
-    _,
-    bufnr,
-    changedtick,
-    firstline,
-    lastline,
-    new_lastline
-  )
-    -- Detach (nvim_buf_attach) via returning True to on_lines if no clients are attached
-    if tbl_isempty(all_buffer_active_clients[bufnr] or {}) then
-      return true
-    end
-    util.buf_versions[bufnr] = changedtick
-    changetracking.send_changes(bufnr, firstline, lastline, new_lastline)
+---@param _ integer
+---@param bufnr integer
+---@param changedtick integer
+---@param firstline integer
+---@param lastline integer
+---@param new_lastline integer
+---@return true?
+local function text_document_did_change_handler(
+  _,
+  bufnr,
+  changedtick,
+  firstline,
+  lastline,
+  new_lastline
+)
+  -- Detach (nvim_buf_attach) via returning True to on_lines if no clients are attached
+  if tbl_isempty(all_buffer_active_clients[bufnr] or {}) then
+    return true
   end
+  util.buf_versions[bufnr] = changedtick
+  changetracking.send_changes(bufnr, firstline, lastline, new_lastline)
 end
 
 ---Buffer lifecycle handler for textDocument/didSave
+--- @param bufnr integer
 local function text_document_did_save_handler(bufnr)
   bufnr = resolve_bufnr(bufnr)
   local uri = vim.uri_from_bufnr(bufnr)
@@ -1797,7 +1814,7 @@ local function text_document_did_save_handler(bufnr)
     end
     local save_capability = vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'save')
     if save_capability then
-      local included_text
+      local included_text --- @type string?
       if type(save_capability) == 'table' and save_capability.includeText then
         included_text = text(bufnr)
       end
@@ -1826,8 +1843,9 @@ function lsp.buf_attach_client(bufnr, client_id)
   })
   bufnr = resolve_bufnr(bufnr)
   if not api.nvim_buf_is_loaded(bufnr) then
-    local _ = log.warn()
-      and log.warn(string.format('buf_attach_client called on unloaded buffer (id: %d): ', bufnr))
+    if log.warn() then
+      log.warn(string.format('buf_attach_client called on unloaded buffer (id: %d): ', bufnr))
+    end
     return false
   end
   local buffer_client_ids = all_buffer_active_clients[bufnr]
@@ -2087,7 +2105,7 @@ api.nvim_create_autocmd('VimLeavePre', {
       client.stop()
     end
 
-    local timeouts = {}
+    local timeouts = {} --- @type table<integer,integer>
     local max_timeout = 0
     local send_kill = false
 
@@ -2134,7 +2152,7 @@ api.nvim_create_autocmd('VimLeavePre', {
 ---@param bufnr (integer) Buffer handle, or 0 for current.
 ---@param method (string) LSP method name
 ---@param params table|nil Parameters to send to the server
----@param handler? lsp-handler See |lsp-handler|
+---@param handler? lsp.Handler See |lsp-handler|
 ---       If nil, follows resolution strategy defined in |lsp-handler-configuration|
 ---
 ---@return table<integer, integer> client_request_ids Map of client-id:request-id pairs
@@ -2152,7 +2170,7 @@ function lsp.buf_request(bufnr, method, params, handler)
   bufnr = resolve_bufnr(bufnr)
   local method_supported = false
   local clients = lsp.get_clients({ bufnr = bufnr })
-  local client_request_ids = {}
+  local client_request_ids = {} --- @type table<integer,integer>
   for _, client in ipairs(clients) do
     if client.supports_method(method, { bufnr = bufnr }) then
       method_supported = true
@@ -2194,7 +2212,7 @@ end
 --- a `client_id:result` map.
 ---@return function cancel Function that cancels all requests.
 function lsp.buf_request_all(bufnr, method, params, handler)
-  local results = {}
+  local results = {} --- @type table<integer,{error:string, result:any}>
   local result_count = 0
   local expected_result_count = 0
 
@@ -2324,6 +2342,7 @@ function lsp.formatexpr(opts)
       local params = util.make_formatting_params()
       local end_line = vim.fn.getline(end_lnum) --[[@as string]]
       local end_col = util._str_utfindex_enc(end_line, nil, client.offset_encoding)
+      --- @cast params +lsp.DocumentRangeFormattingParams
       params.range = {
         start = {
           line = start_lnum - 1,
@@ -2378,7 +2397,7 @@ end
 ---@return table result is table of (client_id, client) pairs
 ---@deprecated Use |vim.lsp.get_clients()| instead.
 function lsp.buf_get_clients(bufnr)
-  local result = {}
+  local result = {} --- @type table<integer,lsp.Client>
   for _, client in ipairs(lsp.get_clients({ bufnr = resolve_bufnr(bufnr) })) do
     result[client.id] = client
   end
@@ -2432,7 +2451,7 @@ function lsp.for_each_buffer_client(bufnr, fn)
 end
 
 --- Function to manage overriding defaults for LSP handlers.
----@param handler (function) See |lsp-handler|
+---@param handler (lsp.Handler) See |lsp-handler|
 ---@param override_config (table) Table containing the keys to override behavior of the {handler}
 function lsp.with(handler, override_config)
   return function(err, result, ctx, config)
@@ -2497,6 +2516,7 @@ end
 ---     arguments?: any[]
 ---
 --- The second argument is the `ctx` of |lsp-handler|
+--- @type table<string,function>
 lsp.commands = setmetatable({}, {
   __newindex = function(tbl, key, value)
     assert(type(key) == 'string', 'The key for commands in `vim.lsp.commands` must be a string')
-- 
cgit 


From 5a2536de0c4beae4eba50a0d2868983c1690ecc7 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Sun, 17 Dec 2023 09:54:38 +0000
Subject: refactor(lsp): move changetracking to separate file (#26577)

* refactor(lsp): move changetracking to separate file

- Prefixed changetracking types with `vim.lsp.`

* fixup!: make _reset_timer a local function

* fixup!: remove @private annotations

* fixup!: changetracking.lua -> _changetracking.lua

* fixup! types

* fixup! add send_changes_for_group
---
 runtime/lua/vim/lsp.lua | 364 ++----------------------------------------------
 1 file changed, 9 insertions(+), 355 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 31aacd668b..6476335213 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -5,7 +5,7 @@ local lsp_rpc = require('vim.lsp.rpc')
 local protocol = require('vim.lsp.protocol')
 local ms = protocol.Methods
 local util = require('vim.lsp.util')
-local sync = require('vim.lsp.sync')
+local changetracking = require('vim.lsp._changetracking')
 local semantic_tokens = require('vim.lsp.semantic_tokens')
 
 local api = vim.api
@@ -132,9 +132,10 @@ local format_line_ending = {
   ['mac'] = '\r',
 }
 
+---@private
 ---@param bufnr (number)
 ---@return string
-local function buf_get_line_ending(bufnr)
+function lsp._buf_get_line_ending(bufnr)
   return format_line_ending[vim.bo[bufnr].fileformat] or '\n'
 end
 
@@ -305,12 +306,13 @@ local function validate_client_config(config)
   return cmd, cmd_args, offset_encoding
 end
 
+---@private
 --- Returns full text of buffer {bufnr} as a string.
 ---
 ---@param bufnr (number) Buffer handle, or 0 for current.
 ---@return string # Buffer text as string.
-local function buf_get_full_text(bufnr)
-  local line_ending = buf_get_line_ending(bufnr)
+function lsp._buf_get_full_text(bufnr)
+  local line_ending = lsp._buf_get_line_ending(bufnr)
   local text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, true), line_ending)
   if vim.bo[bufnr].eol then
     text = text .. line_ending
@@ -338,354 +340,6 @@ local function once(fn)
   end
 end
 
-local changetracking = {}
-do
-  ---@private
-  ---
-  --- LSP has 3 different sync modes:
-  ---   - None (Servers will read the files themselves when needed)
-  ---   - Full (Client sends the full buffer content on updates)
-  ---   - Incremental (Client sends only the changed parts)
-  ---
-  --- Changes are tracked per buffer.
-  --- A buffer can have multiple clients attached and each client needs to send the changes
-  --- To minimize the amount of changesets to compute, computation is grouped:
-  ---
-  ---   None: One group for all clients
-  ---   Full: One group for all clients
-  ---   Incremental: One group per `offset_encoding`
-  ---
-  --- Sending changes can be debounced per buffer. To simplify the implementation the
-  --- smallest debounce interval is used and we don't group clients by different intervals.
-  ---
-  --- @class CTGroup
-  --- @field sync_kind integer TextDocumentSyncKind, considers config.flags.allow_incremental_sync
-  --- @field offset_encoding "utf-8"|"utf-16"|"utf-32"
-  ---
-  --- @class CTBufferState
-  --- @field name string name of the buffer
-  --- @field lines string[] snapshot of buffer lines from last didChange
-  --- @field lines_tmp string[]
-  --- @field pending_changes table[] List of debounced changes in incremental sync mode
-  --- @field timer nil|uv.uv_timer_t uv_timer
-  --- @field last_flush nil|number uv.hrtime of the last flush/didChange-notification
-  --- @field needs_flush boolean true if buffer updates haven't been sent to clients/servers yet
-  --- @field refs integer how many clients are using this group
-  ---
-  --- @class CTGroupState
-  --- @field buffers table<integer, CTBufferState>
-  --- @field debounce integer debounce duration in ms
-  --- @field clients table<integer, table> clients using this state. {client_id, client}
-
-  ---@param group CTGroup
-  ---@return string
-  local function group_key(group)
-    if group.sync_kind == protocol.TextDocumentSyncKind.Incremental then
-      return tostring(group.sync_kind) .. '\0' .. group.offset_encoding
-    end
-    return tostring(group.sync_kind)
-  end
-
-  ---@private
-  ---@type table<CTGroup, CTGroupState>
-  local state_by_group = setmetatable({}, {
-    __index = function(tbl, k)
-      return rawget(tbl, group_key(k))
-    end,
-    __newindex = function(tbl, k, v)
-      rawset(tbl, group_key(k), v)
-    end,
-  })
-
-  ---@param client lsp.Client
-  ---@return CTGroup
-  local function get_group(client)
-    local allow_inc_sync = if_nil(client.config.flags.allow_incremental_sync, true)
-    local change_capability = vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'change')
-    local sync_kind = change_capability or protocol.TextDocumentSyncKind.None
-    if not allow_inc_sync and change_capability == protocol.TextDocumentSyncKind.Incremental then
-      sync_kind = protocol.TextDocumentSyncKind.Full --[[@as integer]]
-    end
-    return {
-      sync_kind = sync_kind,
-      offset_encoding = client.offset_encoding,
-    }
-  end
-
-  ---@param state CTBufferState
-  local function incremental_changes(state, encoding, bufnr, firstline, lastline, new_lastline)
-    local prev_lines = state.lines
-    local curr_lines = state.lines_tmp
-
-    local changed_lines = nvim_buf_get_lines(bufnr, firstline, new_lastline, true)
-    for i = 1, firstline do
-      curr_lines[i] = prev_lines[i]
-    end
-    for i = firstline + 1, new_lastline do
-      curr_lines[i] = changed_lines[i - firstline]
-    end
-    for i = lastline + 1, #prev_lines do
-      curr_lines[i - lastline + new_lastline] = prev_lines[i]
-    end
-    if tbl_isempty(curr_lines) then
-      -- Can happen when deleting the entire contents of a buffer, see https://github.com/neovim/neovim/issues/16259.
-      curr_lines[1] = ''
-    end
-
-    local line_ending = buf_get_line_ending(bufnr)
-    local incremental_change = sync.compute_diff(
-      state.lines,
-      curr_lines,
-      firstline,
-      lastline,
-      new_lastline,
-      encoding,
-      line_ending
-    )
-
-    -- Double-buffering of lines tables is used to reduce the load on the garbage collector.
-    -- At this point the prev_lines table is useless, but its internal storage has already been allocated,
-    -- so let's keep it around for the next didChange event, in which it will become the next
-    -- curr_lines table. Note that setting elements to nil doesn't actually deallocate slots in the
-    -- internal storage - it merely marks them as free, for the GC to deallocate them.
-    for i in ipairs(prev_lines) do
-      prev_lines[i] = nil
-    end
-    state.lines = curr_lines
-    state.lines_tmp = prev_lines
-
-    return incremental_change
-  end
-
-  ---@private
-  function changetracking.init(client, bufnr)
-    assert(client.offset_encoding, 'lsp client must have an offset_encoding')
-    local group = get_group(client)
-    local state = state_by_group[group]
-    if state then
-      state.debounce = math.min(state.debounce, client.config.flags.debounce_text_changes or 150)
-      state.clients[client.id] = client
-    else
-      state = {
-        buffers = {},
-        debounce = client.config.flags.debounce_text_changes or 150,
-        clients = {
-          [client.id] = client,
-        },
-      }
-      state_by_group[group] = state
-    end
-    local buf_state = state.buffers[bufnr]
-    if buf_state then
-      buf_state.refs = buf_state.refs + 1
-    else
-      buf_state = {
-        name = api.nvim_buf_get_name(bufnr),
-        lines = {},
-        lines_tmp = {},
-        pending_changes = {},
-        needs_flush = false,
-        refs = 1,
-      }
-      state.buffers[bufnr] = buf_state
-      if group.sync_kind == protocol.TextDocumentSyncKind.Incremental then
-        buf_state.lines = nvim_buf_get_lines(bufnr, 0, -1, true)
-      end
-    end
-  end
-
-  ---@private
-  function changetracking._get_and_set_name(client, bufnr, name)
-    local state = state_by_group[get_group(client)] or {}
-    local buf_state = (state.buffers or {})[bufnr]
-    local old_name = buf_state.name
-    buf_state.name = name
-    return old_name
-  end
-
-  ---@private
-  function changetracking.reset_buf(client, bufnr)
-    changetracking.flush(client, bufnr)
-    local state = state_by_group[get_group(client)]
-    if not state then
-      return
-    end
-    assert(state.buffers, 'CTGroupState must have buffers')
-    local buf_state = state.buffers[bufnr]
-    buf_state.refs = buf_state.refs - 1
-    assert(buf_state.refs >= 0, 'refcount on buffer state must not get negative')
-    if buf_state.refs == 0 then
-      state.buffers[bufnr] = nil
-      changetracking._reset_timer(buf_state)
-    end
-  end
-
-  ---@private
-  function changetracking.reset(client)
-    local state = state_by_group[get_group(client)]
-    if not state then
-      return
-    end
-    state.clients[client.id] = nil
-    if vim.tbl_count(state.clients) == 0 then
-      for _, buf_state in pairs(state.buffers) do
-        changetracking._reset_timer(buf_state)
-      end
-      state.buffers = {}
-    end
-  end
-
-  -- Adjust debounce time by taking time of last didChange notification into
-  -- consideration. If the last didChange happened more than `debounce` time ago,
-  -- debounce can be skipped and otherwise maybe reduced.
-  --
-  -- This turns the debounce into a kind of client rate limiting
-  --
-  ---@param debounce integer
-  ---@param buf_state CTBufferState
-  ---@return number
-  local function next_debounce(debounce, buf_state)
-    if debounce == 0 then
-      return 0
-    end
-    local ns_to_ms = 0.000001
-    if not buf_state.last_flush then
-      return debounce
-    end
-    local now = uv.hrtime()
-    local ms_since_last_flush = (now - buf_state.last_flush) * ns_to_ms
-    return math.max(debounce - ms_since_last_flush, 0)
-  end
-
-  ---@param bufnr integer
-  ---@param sync_kind integer protocol.TextDocumentSyncKind
-  ---@param state CTGroupState
-  ---@param buf_state CTBufferState
-  local function send_changes(bufnr, sync_kind, state, buf_state)
-    if not buf_state.needs_flush then
-      return
-    end
-    buf_state.last_flush = uv.hrtime()
-    buf_state.needs_flush = false
-
-    if not api.nvim_buf_is_valid(bufnr) then
-      buf_state.pending_changes = {}
-      return
-    end
-
-    local changes --- @type lsp.TextDocumentContentChangeEvent[]
-    if sync_kind == protocol.TextDocumentSyncKind.None then
-      return
-    elseif sync_kind == protocol.TextDocumentSyncKind.Incremental then
-      changes = buf_state.pending_changes
-      buf_state.pending_changes = {}
-    else
-      changes = {
-        { text = buf_get_full_text(bufnr) },
-      }
-    end
-    local uri = vim.uri_from_bufnr(bufnr)
-    for _, client in pairs(state.clients) do
-      if not client.is_stopped() and lsp.buf_is_attached(bufnr, client.id) then
-        client.notify(ms.textDocument_didChange, {
-          textDocument = {
-            uri = uri,
-            version = util.buf_versions[bufnr],
-          },
-          contentChanges = changes,
-        })
-      end
-    end
-  end
-
-  ---@private
-  function changetracking.send_changes(bufnr, firstline, lastline, new_lastline)
-    local groups = {} ---@type table<string,CTGroup>
-    for _, client in pairs(lsp.get_clients({ bufnr = bufnr })) do
-      local group = get_group(client)
-      groups[group_key(group)] = group
-    end
-    for _, group in pairs(groups) do
-      local state = state_by_group[group]
-      if not state then
-        error(
-          string.format(
-            'changetracking.init must have been called for all LSP clients. group=%s states=%s',
-            vim.inspect(group),
-            vim.inspect(vim.tbl_keys(state_by_group))
-          )
-        )
-      end
-      local buf_state = state.buffers[bufnr]
-      buf_state.needs_flush = true
-      changetracking._reset_timer(buf_state)
-      local debounce = next_debounce(state.debounce, buf_state)
-      if group.sync_kind == protocol.TextDocumentSyncKind.Incremental then
-        -- This must be done immediately and cannot be delayed
-        -- The contents would further change and startline/endline may no longer fit
-        local changes = incremental_changes(
-          buf_state,
-          group.offset_encoding,
-          bufnr,
-          firstline,
-          lastline,
-          new_lastline
-        )
-        table.insert(buf_state.pending_changes, changes)
-      end
-      if debounce == 0 then
-        send_changes(bufnr, group.sync_kind, state, buf_state)
-      else
-        local timer = assert(uv.new_timer(), 'Must be able to create timer')
-        buf_state.timer = timer
-        timer:start(
-          debounce,
-          0,
-          vim.schedule_wrap(function()
-            changetracking._reset_timer(buf_state)
-            send_changes(bufnr, group.sync_kind, state, buf_state)
-          end)
-        )
-      end
-    end
-  end
-
-  ---@private
-  ---@param buf_state CTBufferState
-  function changetracking._reset_timer(buf_state)
-    local timer = buf_state.timer
-    if timer then
-      buf_state.timer = nil
-      if not timer:is_closing() then
-        timer:stop()
-        timer:close()
-      end
-    end
-  end
-
-  --- Flushes any outstanding change notification.
-  ---@private
-  ---@param client lsp.Client
-  ---@param bufnr? integer
-  function changetracking.flush(client, bufnr)
-    local group = get_group(client)
-    local state = state_by_group[group]
-    if not state then
-      return
-    end
-    if bufnr then
-      local buf_state = state.buffers[bufnr] or {}
-      changetracking._reset_timer(buf_state)
-      send_changes(bufnr, group.sync_kind, state, buf_state)
-    else
-      for buf, buf_state in pairs(state.buffers) do
-        changetracking._reset_timer(buf_state)
-        send_changes(buf, group.sync_kind, state, buf_state)
-      end
-    end
-  end
-end
-
 --- Default handler for the 'textDocument/didOpen' LSP notification.
 ---
 ---@param bufnr integer Number of the buffer, or 0 for current
@@ -705,7 +359,7 @@ local function text_document_did_open_handler(bufnr, client)
       version = 0,
       uri = vim.uri_from_bufnr(bufnr),
       languageId = client.config.get_language_id(bufnr, filetype),
-      text = buf_get_full_text(bufnr),
+      text = lsp._buf_get_full_text(bufnr),
     },
   }
   client.notify(ms.textDocument_didOpen, params)
@@ -1792,7 +1446,7 @@ end
 local function text_document_did_save_handler(bufnr)
   bufnr = resolve_bufnr(bufnr)
   local uri = vim.uri_from_bufnr(bufnr)
-  local text = once(buf_get_full_text)
+  local text = once(lsp._buf_get_full_text)
   for _, client in ipairs(lsp.get_clients({ bufnr = bufnr })) do
     local name = api.nvim_buf_get_name(bufnr)
     local old_name = changetracking._get_and_set_name(client, bufnr, name)
@@ -1807,7 +1461,7 @@ local function text_document_did_save_handler(bufnr)
           version = 0,
           uri = uri,
           languageId = client.config.get_language_id(bufnr, vim.bo[bufnr].filetype),
-          text = buf_get_full_text(bufnr),
+          text = lsp._buf_get_full_text(bufnr),
         },
       })
       util.buf_versions[bufnr] = 0
-- 
cgit 


From 031088fc0afffe4af6fa90d68d5b93ca09992ef1 Mon Sep 17 00:00:00 2001
From: Michal Liszcz <liszcz.michal@gmail.com>
Date: Fri, 22 Dec 2023 15:03:13 +0100
Subject: fix(lsp): filetype matching to documentSelector in dynamic
 capabilities (#25425)

Use the get_language_id client option to resolve the filetype when
matching the document selector in a dynamic capability.


Co-authored-by: Mathias Fussenegger <f.mathias@zignar.net>
---
 runtime/lua/vim/lsp.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 6476335213..ca7222a8f3 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1073,7 +1073,7 @@ function lsp.start_client(config)
     end
 
     --- @param method string
-    --- @param opts? {bufnr?: number}
+    --- @param opts? {bufnr: integer?}
     client.supports_method = function(method, opts)
       opts = opts or {}
       local required_capability = lsp._request_name_to_capability[method]
-- 
cgit 


From 5f9d4d8afeb5dc3d5df4965c24cbb4c6e01694f7 Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Mon, 25 Dec 2023 21:28:28 +0100
Subject: refactor: use vim.deprecate on all deprecated functions

---
 runtime/lua/vim/lsp.lua | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index ca7222a8f3..1310239a5b 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1740,7 +1740,7 @@ end
 ---@private
 ---@deprecated
 function lsp.get_active_clients(filter)
-  -- TODO: add vim.deprecate call after 0.10 is out for removal in 0.12
+  vim.deprecate('vim.lsp.get_active_clients()', 'vim.lsp.get_clients()', '0.12')
   return lsp.get_clients(filter)
 end
 
@@ -2051,6 +2051,7 @@ end
 ---@return table result is table of (client_id, client) pairs
 ---@deprecated Use |vim.lsp.get_clients()| instead.
 function lsp.buf_get_clients(bufnr)
+  vim.deprecate('vim.lsp.buf_get_clients()', 'vim.lsp.get_clients()', '0.12')
   local result = {} --- @type table<integer,lsp.Client>
   for _, client in ipairs(lsp.get_clients({ bufnr = resolve_bufnr(bufnr) })) do
     result[client.id] = client
@@ -2101,6 +2102,11 @@ end
 ---                   buffer number as arguments.
 ---@deprecated use lsp.get_clients({ bufnr = bufnr }) with regular loop
 function lsp.for_each_buffer_client(bufnr, fn)
+  vim.deprecate(
+    'vim.lsp.for_each_buffer_client()',
+    'lsp.get_clients({ bufnr = bufnr }) with regular loop',
+    '0.12'
+  )
   return for_each_buffer_client(bufnr, fn)
 end
 
-- 
cgit 


From d51b6157473c4830313b566116aa3ad38dc97412 Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Wed, 13 Dec 2023 14:04:24 +0100
Subject: refactor: fix luals warnings

---
 runtime/lua/vim/lsp.lua | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 1310239a5b..3105413b53 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -329,11 +329,11 @@ end
 ---@param fn (T) Function to run
 ---@return T
 local function once(fn)
-  local value --- @type any
+  local value --- @type function
   local ran = false
   return function(...)
     if not ran then
-      value = fn(...)
+      value = fn(...) --- @type function
       ran = true
     end
     return value
-- 
cgit 


From 91d76ac941a26f8370c48e062b5e09f98c75f7bc Mon Sep 17 00:00:00 2001
From: Mathias Fußenegger <mfussenegger@users.noreply.github.com>
Date: Tue, 2 Jan 2024 18:52:29 +0100
Subject: docs(lsp): add supports_method to vim.lsp.client docs (#26852)

---
 runtime/lua/vim/lsp.lua | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 3105413b53..27c5f7ce7b 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -425,6 +425,12 @@ end
 ---     Runs the on_attach function from the client's config if it was defined.
 ---     Useful for buffer-local setup.
 ---
+---  - supports_method(method, [opts]): 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.
+---
 --- - Members
 ---  - {id} (number): The id allocated to the client.
 ---
-- 
cgit 


From 3734519e3b4ba1bf19ca772104170b0ef776be46 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Tue, 2 Jan 2024 15:47:55 +0000
Subject: feat(lua): add noref to deepcopy

Problem:

Currently `deepcopy` hashes every single tables it copies so it can be
reused. For tables of mostly unique items that are non recursive, this
hashing is unnecessarily expensive

Solution:

Port the `noref` argument from Vimscripts `deepcopy()`.

The below benchmark demonstrates the results for two extreme cases of
tables of different sizes. One table that uses the same table lots of
times and one with all unique tables.

| test                 | `noref=false` (ms) | `noref=true` (ms) |
| -------------------- | ------------------ | ----------------- |
| unique tables (50)   | 6.59               | 2.62              |
| shared tables (50)   | 3.24               | 6.40              |
| unique tables (2000) | 23381.48           | 2884.53           |
| shared tables (2000) | 3505.54            | 14038.80          |

The results are basically the inverse of each other where `noref` is
much more performance on tables with unique fields, and `not noref` is
more performant on tables that reuse fields.
---
 runtime/lua/vim/lsp.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 27c5f7ce7b..b2aa943359 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1353,7 +1353,7 @@ function lsp.start_client(config)
   ---@param context? {bufnr: integer}
   ---@param handler? lsp.Handler only called if a server command
   function client._exec_cmd(command, context, handler)
-    context = vim.deepcopy(context or {}) --[[@as lsp.HandlerContext]]
+    context = vim.deepcopy(context or {}, true) --[[@as lsp.HandlerContext]]
     context.bufnr = context.bufnr or api.nvim_get_current_buf()
     context.client_id = client.id
     local cmdname = command.command
-- 
cgit 


From ce4ea638c703275aedadb3794efc56dcb782c908 Mon Sep 17 00:00:00 2001
From: Jongwook Choi <wookayin@gmail.com>
Date: Tue, 9 Jan 2024 18:04:27 -0500
Subject: fix(lsp): fix incorrect typing and doc for `vim.lsp.rpc`

Typings introduced in #26032 and #26552 have a few conflicts, so we
merge and clean them up. We also fix some incorrect type annotation in
the `vim.lsp.rpc` package. See the associated PR for more details.

Summary:

- vim.rpc.Dispatchers -> vim.lsp.rpc.Dispatchers
- vim.lsp.rpc.Error -> lsp.ResponseError
- Revise docs
---
 runtime/lua/vim/lsp.lua | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index b2aa943359..a02a93d559 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -258,7 +258,7 @@ end
 --- Validates a client configuration as given to |vim.lsp.start_client()|.
 ---
 ---@param config (lsp.ClientConfig)
----@return (string|fun(dispatchers:vim.rpc.Dispatchers):RpcClientPublic?) Command
+---@return (string|fun(dispatchers:vim.rpc.Dispatchers):vim.lsp.rpc.PublicClient?) Command
 ---@return string[] Arguments
 ---@return string Encoding.
 local function validate_client_config(config)
@@ -291,7 +291,7 @@ local function validate_client_config(config)
     'flags.debounce_text_changes must be a number with the debounce time in milliseconds'
   )
 
-  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.rpc.Dispatchers):RpcClientPublic), string[]
+  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.rpc.Dispatchers):vim.lsp.rpc.PublicClient), string[]
   local config_cmd = config.cmd
   if type(config_cmd) == 'function' then
     cmd = config_cmd
@@ -826,6 +826,8 @@ function lsp.start_client(config)
   ---
   ---@param method (string) LSP method name
   ---@param params (table) The parameters for that method
+  ---@return any result
+  ---@return lsp.ResponseError error code and message set in case an exception happens during the request.
   function dispatch.server_request(method, params)
     if log.trace() then
       log.trace('server_request', method, params)
@@ -953,7 +955,7 @@ function lsp.start_client(config)
   end
 
   -- Start the RPC client.
-  local rpc --- @type RpcClientPublic?
+  local rpc --- @type vim.lsp.rpc.PublicClient?
   if type(cmd) == 'function' then
     rpc = cmd(dispatch)
   else
-- 
cgit 


From 95cbedaa1798a7c1489b68dd60380a41443ed34b Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Thu, 18 Jan 2024 00:14:48 -0800
Subject: docs: various #25289

Co-authored-by: Jongwook Choi <wookayin@gmail.com>
Co-authored-by: Oliver Marriott <hello@omarriott.com>
Co-authored-by: Benoit de Chezelles <bew@users.noreply.github.com>
Co-authored-by: Jongwook Choi <wookayin@gmail.com>
---
 runtime/lua/vim/lsp.lua | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index a02a93d559..f3448209ba 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -488,8 +488,7 @@ end
 --- See |vim.lsp.start_client()| for all available options. The most important are:
 ---
 --- - `name` arbitrary name for the LSP client. Should be unique per language server.
---- - `cmd` command (in list form) used to start the language server. Must be absolute, or found on
----   `$PATH`. Shell constructs like `~` are not expanded.
+--- - `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.find()| and |vim.fs.dirname()| to detect the
 ---   root by traversing the file system upwards starting from the current directory until either
@@ -666,13 +665,13 @@ end
 --- Field `cmd` in {config} is required.
 ---
 ---@param config (lsp.ClientConfig) Configuration for the server:
---- - cmd: (string[]|fun(dispatchers: table):table) command a list of
----       strings treated like |jobstart()|. The command must launch the language server
----       process. `cmd` can also be a function that creates an RPC client.
----       The function receives a dispatchers table and must return a table with the
----       functions `request`, `notify`, `is_closing` and `terminate`
----       See |vim.lsp.rpc.request()| and |vim.lsp.rpc.notify()|
----       For TCP there is a built-in rpc client factory: |vim.lsp.rpc.connect()|
+--- - cmd: (string[]|fun(dispatchers: table):table) 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=|getcwd()|) Directory to launch
 ---       the `cmd` process. Not related to `root_dir`.
-- 
cgit 


From 2e982f1aad9f1a03562b7a451d642f76b04c37cb Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Mon, 22 Jan 2024 18:23:28 +0100
Subject: refactor: create function for deferred loading

The benefit of this is that users only pay for what they use. If e.g.
only `vim.lsp.buf_get_clients()` is called then they don't need to load
all modules under `vim.lsp` which could lead to significant startuptime
saving.

Also `vim.lsp.module` is a bit nicer to user compared to
`require("vim.lsp.module")`.

This isn't used for some nested modules such as `filetype` as it breaks
tests with error messages such as "attempt to index field 'detect'".
It's not entirely certain the reason for this, but it is likely it is
due to filetype being precompiled which would imply deferred loading
isn't needed for performance reasons.
---
 runtime/lua/vim/lsp.lua | 71 +++++++++++++++++++++++++------------------------
 1 file changed, 36 insertions(+), 35 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index f3448209ba..5fa5a1db29 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1,13 +1,4 @@
 ---@diagnostic disable: invisible
-local default_handlers = require('vim.lsp.handlers')
-local log = require('vim.lsp.log')
-local lsp_rpc = require('vim.lsp.rpc')
-local protocol = require('vim.lsp.protocol')
-local ms = protocol.Methods
-local util = require('vim.lsp.util')
-local changetracking = require('vim.lsp._changetracking')
-local semantic_tokens = require('vim.lsp.semantic_tokens')
-
 local api = vim.api
 local nvim_err_writeln, nvim_buf_get_lines, nvim_command, nvim_exec_autocmds =
   api.nvim_err_writeln, api.nvim_buf_get_lines, api.nvim_command, api.nvim_exec_autocmds
@@ -16,24 +7,34 @@ local tbl_isempty, tbl_extend = vim.tbl_isempty, vim.tbl_extend
 local validate = vim.validate
 local if_nil = vim.F.if_nil
 
-local lsp = {
-  protocol = protocol,
-
-  handlers = default_handlers,
-
-  buf = require('vim.lsp.buf'),
-  diagnostic = require('vim.lsp.diagnostic'),
-  codelens = require('vim.lsp.codelens'),
-  inlay_hint = require('vim.lsp.inlay_hint'),
-  semantic_tokens = semantic_tokens,
-  util = util,
+local lsp = vim._defer_require('vim.lsp', {
+  _changetracking = ..., --- @module 'vim.lsp._changetracking'
+  _completion = ..., --- @module 'vim.lsp._completion'
+  _dynamic = ..., --- @module 'vim.lsp._dynamic'
+  _snippet_grammar = ..., --- @module 'vim.lsp._snippet_grammar'
+  _watchfiles = ..., --- @module 'vim.lsp._watchfiles'
+  buf = ..., --- @module 'vim.lsp.buf'
+  codelens = ..., --- @module 'vim.lsp.codelens'
+  diagnostic = ..., --- @module 'vim.lsp.diagnostic'
+  handlers = ..., --- @module 'vim.lsp.handlers'
+  inlay_hint = ..., --- @module 'vim.lsp.inlay_hint'
+  log = ..., --- @module 'vim.lsp.log'
+  protocol = ..., --- @module 'vim.lsp.protocol'
+  rpc = ..., --- @module 'vim.lsp.rpc'
+  semantic_tokens = ..., --- @module 'vim.lsp.semantic_tokens'
+  tagfunc = ..., --- @module 'vim.lsp.tagfunc'
+  util = ..., --- @module 'vim.lsp.util'
+})
 
-  -- Allow raw RPC access.
-  rpc = lsp_rpc,
+local log = lsp.log
+local protocol = lsp.protocol
+local ms = protocol.Methods
+local util = lsp.util
+local changetracking = lsp._changetracking
 
-  -- Export these directly from rpc.
-  rpc_response_error = lsp_rpc.rpc_response_error,
-}
+-- Export these directly from rpc.
+---@nodoc
+lsp.rpc_response_error = lsp.rpc.rpc_response_error
 
 -- maps request name to the required server_capability in the client.
 lsp._request_name_to_capability = {
@@ -189,11 +190,11 @@ end
 --- @nodoc
 lsp.client_errors = tbl_extend(
   'error',
-  lsp_rpc.client_errors,
+  lsp.rpc.client_errors,
   vim.tbl_add_reverse_lookup({
-    BEFORE_INIT_CALLBACK_ERROR = table.maxn(lsp_rpc.client_errors) + 1,
-    ON_INIT_CALLBACK_ERROR = table.maxn(lsp_rpc.client_errors) + 2,
-    ON_ATTACH_ERROR = table.maxn(lsp_rpc.client_errors) + 3,
+    BEFORE_INIT_CALLBACK_ERROR = table.maxn(lsp.rpc.client_errors) + 1,
+    ON_INIT_CALLBACK_ERROR = table.maxn(lsp.rpc.client_errors) + 2,
+    ON_ATTACH_ERROR = table.maxn(lsp.rpc.client_errors) + 3,
   })
 )
 
@@ -800,7 +801,7 @@ function lsp.start_client(config)
   ---@param method (string) LSP method name
   ---@return lsp.Handler|nil handler for the given method, if defined, or the default from |vim.lsp.handlers|
   local function resolve_handler(method)
-    return handlers[method] or default_handlers[method]
+    return handlers[method] or lsp.handlers[method]
   end
 
   ---@private
@@ -958,7 +959,7 @@ function lsp.start_client(config)
   if type(cmd) == 'function' then
     rpc = cmd(dispatch)
   else
-    rpc = lsp_rpc.start(cmd, cmd_args, dispatch, {
+    rpc = lsp.rpc.start(cmd, cmd_args, dispatch, {
       cwd = config.cmd_cwd,
       env = config.cmd_env,
       detached = config.detached,
@@ -999,7 +1000,7 @@ function lsp.start_client(config)
 
     ---@deprecated use client.progress instead
     messages = { name = name, messages = {}, progress = {}, status = {} },
-    dynamic_capabilities = require('vim.lsp._dynamic').new(client_id),
+    dynamic_capabilities = vim.lsp._dynamic.new(client_id),
   }
 
   ---@type table<string|integer, string> title of unfinished progress sequences by token
@@ -1412,7 +1413,7 @@ function lsp.start_client(config)
     -- opt-out (deleting the semanticTokensProvider from capabilities)
     vim.schedule(function()
       if vim.tbl_get(client.server_capabilities, 'semanticTokensProvider', 'full') then
-        semantic_tokens.start(bufnr, client.id)
+        lsp.semantic_tokens.start(bufnr, client.id)
       end
     end)
 
@@ -1969,7 +1970,7 @@ function lsp.omnifunc(findstart, base)
   if log.debug() then
     log.debug('omnifunc.findstart', { findstart = findstart, base = base })
   end
-  return require('vim.lsp._completion').omnifunc(findstart, base)
+  return vim.lsp._completion.omnifunc(findstart, base)
 end
 
 --- Provides an interface between the built-in client and a `formatexpr` function.
@@ -2039,7 +2040,7 @@ end
 ---
 ---@return table[] tags A list of matching tags
 function lsp.tagfunc(pattern, flags)
-  return require('vim.lsp.tagfunc')(pattern, flags)
+  return vim.lsp.tagfunc(pattern, flags)
 end
 
 ---Checks whether a client is stopped.
-- 
cgit 


From f487e5af019c7cd0f15ab9beb522c9358e8013e2 Mon Sep 17 00:00:00 2001
From: Jongwook Choi <wookayin@gmail.com>
Date: Sat, 3 Feb 2024 17:47:56 -0500
Subject: fix(lsp): fix infinite loop on vim.lsp.tagfunc

Problem: vim.lsp.tagfunc() causes an infinite loop.

This is a bug happened while introducing deferred loading.

Solution: Rename the private module to `vim.lsp._tagfunc`.
---
 runtime/lua/vim/lsp.lua | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 5fa5a1db29..d8d47a8464 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -12,6 +12,7 @@ local lsp = vim._defer_require('vim.lsp', {
   _completion = ..., --- @module 'vim.lsp._completion'
   _dynamic = ..., --- @module 'vim.lsp._dynamic'
   _snippet_grammar = ..., --- @module 'vim.lsp._snippet_grammar'
+  _tagfunc = ..., --- @module 'vim.lsp._tagfunc'
   _watchfiles = ..., --- @module 'vim.lsp._watchfiles'
   buf = ..., --- @module 'vim.lsp.buf'
   codelens = ..., --- @module 'vim.lsp.codelens'
@@ -22,7 +23,6 @@ local lsp = vim._defer_require('vim.lsp', {
   protocol = ..., --- @module 'vim.lsp.protocol'
   rpc = ..., --- @module 'vim.lsp.rpc'
   semantic_tokens = ..., --- @module 'vim.lsp.semantic_tokens'
-  tagfunc = ..., --- @module 'vim.lsp.tagfunc'
   util = ..., --- @module 'vim.lsp.util'
 })
 
@@ -2040,7 +2040,7 @@ end
 ---
 ---@return table[] tags A list of matching tags
 function lsp.tagfunc(pattern, flags)
-  return vim.lsp.tagfunc(pattern, flags)
+  return vim.lsp._tagfunc(pattern, flags)
 end
 
 ---Checks whether a client is stopped.
-- 
cgit 


From 59cf827f99d53ec8dbb90e48a7561c0cb8b8ca6f Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Wed, 7 Feb 2024 17:22:03 +0000
Subject: refactor(lsp): move client code to a regular Lua class

Problem:
  The LSP client code is implemented as a complicated closure-class
  (class defined in a single function).

Solution:
  Move LSP client code to a more conventional Lua class and move to a
  separate file.
---
 runtime/lua/vim/lsp.lua | 543 ++++--------------------------------------------
 1 file changed, 40 insertions(+), 503 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index d8d47a8464..dc50ab0267 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -15,6 +15,7 @@ local lsp = vim._defer_require('vim.lsp', {
   _tagfunc = ..., --- @module 'vim.lsp._tagfunc'
   _watchfiles = ..., --- @module 'vim.lsp._watchfiles'
   buf = ..., --- @module 'vim.lsp.buf'
+  client = ..., --- @module 'vim.lsp.client'
   codelens = ..., --- @module 'vim.lsp.codelens'
   diagnostic = ..., --- @module 'vim.lsp.diagnostic'
   handlers = ..., --- @module 'vim.lsp.handlers'
@@ -259,7 +260,7 @@ end
 --- Validates a client configuration as given to |vim.lsp.start_client()|.
 ---
 ---@param config (lsp.ClientConfig)
----@return (string|fun(dispatchers:vim.rpc.Dispatchers):vim.lsp.rpc.PublicClient?) Command
+---@return (string|fun(dispatchers:vim.lsp.rpc.Dispatchers):vim.lsp.rpc.PublicClient?) Command
 ---@return string[] Arguments
 ---@return string Encoding.
 local function validate_client_config(config)
@@ -292,7 +293,7 @@ local function validate_client_config(config)
     'flags.debounce_text_changes must be a number with the debounce time in milliseconds'
   )
 
-  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.rpc.Dispatchers):vim.lsp.rpc.PublicClient), string[]
+  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.lsp.rpc.Dispatchers):vim.lsp.rpc.PublicClient), string[]
   local config_cmd = config.cmd
   if type(config_cmd) == 'function' then
     cmd = config_cmd
@@ -341,42 +342,6 @@ local function once(fn)
   end
 end
 
---- Default handler for the 'textDocument/didOpen' LSP notification.
----
----@param bufnr integer Number of the buffer, or 0 for current
----@param client lsp.Client Client object
-local function text_document_did_open_handler(bufnr, client)
-  changetracking.init(client, bufnr)
-  if not vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'openClose') then
-    return
-  end
-  if not api.nvim_buf_is_loaded(bufnr) then
-    return
-  end
-  local filetype = vim.bo[bufnr].filetype
-
-  local params = {
-    textDocument = {
-      version = 0,
-      uri = vim.uri_from_bufnr(bufnr),
-      languageId = client.config.get_language_id(bufnr, filetype),
-      text = lsp._buf_get_full_text(bufnr),
-    },
-  }
-  client.notify(ms.textDocument_didOpen, params)
-  util.buf_versions[bufnr] = params.textDocument.version
-
-  -- Next chance we get, we should re-do the diagnostics
-  vim.schedule(function()
-    -- Protect against a race where the buffer disappears
-    -- between `did_open_handler` and the scheduled function firing.
-    if api.nvim_buf_is_valid(bufnr) then
-      local namespace = vim.lsp.diagnostic.get_namespace(client.id)
-      vim.diagnostic.show(namespace, bufnr)
-    end
-  end)
-end
-
 -- FIXME: DOC: Shouldn't need to use a dummy function
 --
 --- LSP client object. You can get an active client object via
@@ -556,7 +521,9 @@ function lsp.status()
   local percentage = nil
   local messages = {} --- @type string[]
   for _, client in ipairs(vim.lsp.get_clients()) do
+    --- @diagnostic disable-next-line:no-unknown
     for progress in client.progress do
+      --- @cast progress {token: lsp.ProgressToken, value: lsp.LSPAny}
       local value = progress.value
       if type(value) == 'table' and value.kind then
         local message = value.message and (value.title .. ': ' .. value.message) or value.title
@@ -655,6 +622,26 @@ end
 --- @field flags table
 --- @field root_dir string
 
+--- Reset defaults set by `set_defaults`.
+--- Must only be called if the last client attached to a buffer exits.
+local function reset_defaults(bufnr)
+  if vim.bo[bufnr].tagfunc == 'v:lua.vim.lsp.tagfunc' then
+    vim.bo[bufnr].tagfunc = nil
+  end
+  if vim.bo[bufnr].omnifunc == 'v:lua.vim.lsp.omnifunc' then
+    vim.bo[bufnr].omnifunc = nil
+  end
+  if vim.bo[bufnr].formatexpr == 'v:lua.vim.lsp.formatexpr()' then
+    vim.bo[bufnr].formatexpr = nil
+  end
+  api.nvim_buf_call(bufnr, function()
+    local keymap = vim.fn.maparg('K', 'n', false, true)
+    if keymap and keymap.callback == vim.lsp.buf.hover then
+      vim.keymap.del('n', 'K', { buffer = bufnr })
+    end
+  end)
+end
+
 -- FIXME: DOC: Currently all methods on the `vim.lsp.client` object are
 -- documented twice: Here, and on the methods themselves (e.g.
 -- `client.request()`). This is a workaround for the vimdoc generator script
@@ -875,26 +862,6 @@ function lsp.start_client(config)
     end
   end
 
-  --- Reset defaults set by `set_defaults`.
-  --- Must only be called if the last client attached to a buffer exits.
-  local function reset_defaults(bufnr)
-    if vim.bo[bufnr].tagfunc == 'v:lua.vim.lsp.tagfunc' then
-      vim.bo[bufnr].tagfunc = nil
-    end
-    if vim.bo[bufnr].omnifunc == 'v:lua.vim.lsp.omnifunc' then
-      vim.bo[bufnr].omnifunc = nil
-    end
-    if vim.bo[bufnr].formatexpr == 'v:lua.vim.lsp.formatexpr()' then
-      vim.bo[bufnr].formatexpr = nil
-    end
-    api.nvim_buf_call(bufnr, function()
-      local keymap = vim.fn.maparg('K', 'n', false, true)
-      if keymap and keymap.callback == vim.lsp.buf.hover then
-        vim.keymap.del('n', 'K', { buffer = bufnr })
-      end
-    end)
-  end
-
   ---@private
   --- Invoked on client exit.
   ---
@@ -971,456 +938,26 @@ function lsp.start_client(config)
     return
   end
 
-  ---@class lsp.Client
-  local client = {
-    id = client_id,
-    name = name,
-    rpc = rpc,
-    offset_encoding = offset_encoding,
-    config = config,
-    attached_buffers = {}, --- @type table<integer,true>
-
-    handlers = handlers,
-    --- @type table<string,function>
-    commands = config.commands or {},
+  config.capabilities = config.capabilities or protocol.make_client_capabilities()
 
-    --- @type table<integer,{ type: string, bufnr: integer, method: string}>
-    requests = {},
-
-    --- Contains $/progress report messages.
-    --- They have the format {token: integer|string, value: any}
-    --- For "work done progress", value will be one of:
-    --- - lsp.WorkDoneProgressBegin,
-    --- - lsp.WorkDoneProgressReport (extended with title from Begin)
-    --- - lsp.WorkDoneProgressEnd    (extended with title from Begin)
-    progress = vim.ringbuf(50),
-
-    --- @type lsp.ServerCapabilities
-    server_capabilities = {},
-
-    ---@deprecated use client.progress instead
-    messages = { name = name, messages = {}, progress = {}, status = {} },
-    dynamic_capabilities = vim.lsp._dynamic.new(client_id),
-  }
-
-  ---@type table<string|integer, string> title of unfinished progress sequences by token
-  client.progress.pending = {}
-
-  --- @type lsp.ClientCapabilities
-  client.config.capabilities = config.capabilities or protocol.make_client_capabilities()
+  local client = require('vim.lsp.client').new(client_id, rpc, handlers, offset_encoding, config)
 
   -- Store the uninitialized_clients for cleanup in case we exit before initialize finishes.
   uninitialized_clients[client_id] = client
 
-  local function initialize()
-    local valid_traces = {
-      off = 'off',
-      messages = 'messages',
-      verbose = 'verbose',
-    }
-
-    local workspace_folders --- @type lsp.WorkspaceFolder[]?
-    local root_uri --- @type string?
-    local root_path --- @type string?
-    if config.workspace_folders or config.root_dir then
-      if config.root_dir and not config.workspace_folders then
-        workspace_folders = {
-          {
-            uri = vim.uri_from_fname(config.root_dir),
-            name = string.format('%s', config.root_dir),
-          },
-        }
-      else
-        workspace_folders = config.workspace_folders
-      end
-      root_uri = workspace_folders[1].uri
-      root_path = vim.uri_to_fname(root_uri)
-    else
-      workspace_folders = nil
-      root_uri = nil
-      root_path = nil
-    end
-
-    local initialize_params = {
-      -- The process Id of the parent process that started the server. Is null if
-      -- the process has not been started by another process.  If the parent
-      -- process is not alive then the server should exit (see exit notification)
-      -- its process.
-      processId = uv.os_getpid(),
-      -- Information about the client
-      -- since 3.15.0
-      clientInfo = {
-        name = 'Neovim',
-        version = tostring(vim.version()),
-      },
-      -- The rootPath of the workspace. Is null if no folder is open.
-      --
-      -- @deprecated in favour of rootUri.
-      rootPath = root_path or vim.NIL,
-      -- The rootUri of the workspace. Is null if no folder is open. If both
-      -- `rootPath` and `rootUri` are set `rootUri` wins.
-      rootUri = root_uri or vim.NIL,
-      -- 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.
-      workspaceFolders = workspace_folders or vim.NIL,
-      -- User provided initialization options.
-      initializationOptions = config.init_options,
-      -- The capabilities provided by the client (editor or tool)
-      capabilities = config.capabilities,
-      -- The initial trace setting. If omitted trace is disabled ("off").
-      -- trace = "off" | "messages" | "verbose";
-      trace = valid_traces[config.trace] or 'off',
-    }
-    if config.before_init then
-      local status, err = pcall(config.before_init, initialize_params, config)
-      if not status then
-        write_error(lsp.client_errors.BEFORE_INIT_CALLBACK_ERROR, err)
-      end
-    end
-
-    --- @param method string
-    --- @param opts? {bufnr: integer?}
-    client.supports_method = function(method, opts)
-      opts = opts or {}
-      local required_capability = lsp._request_name_to_capability[method]
-      -- if we don't know about the method, assume that the client supports it.
-      if not required_capability then
-        return true
-      end
-      if vim.tbl_get(client.server_capabilities, unpack(required_capability)) then
-        return true
-      else
-        if client.dynamic_capabilities:supports_registration(method) then
-          return client.dynamic_capabilities:supports(method, opts)
-        end
-        return false
-      end
-    end
-
-    if log.trace() then
-      log.trace(log_prefix, 'initialize_params', initialize_params)
-    end
-    rpc.request('initialize', initialize_params, function(init_err, result)
-      assert(not init_err, tostring(init_err))
-      assert(result, 'server sent empty result')
-      rpc.notify('initialized', vim.empty_dict())
-      client.initialized = true
-      uninitialized_clients[client_id] = nil
-      client.workspace_folders = workspace_folders
-
-      -- These are the cleaned up capabilities we use for dynamically deciding
-      -- when to send certain events to clients.
-      client.server_capabilities =
-        assert(result.capabilities, "initialize result doesn't contain capabilities")
-      client.server_capabilities = assert(protocol.resolve_capabilities(client.server_capabilities))
-
-      if client.server_capabilities.positionEncoding then
-        client.offset_encoding = client.server_capabilities.positionEncoding
-      end
-
-      if next(config.settings) then
-        client.notify(ms.workspace_didChangeConfiguration, { settings = config.settings })
-      end
-
-      if config.on_init then
-        local status, err = pcall(config.on_init, client, result)
-        if not status then
-          write_error(lsp.client_errors.ON_INIT_CALLBACK_ERROR, err)
-        end
-      end
-      if log.info() then
-        log.info(
-          log_prefix,
-          'server_capabilities',
-          { server_capabilities = client.server_capabilities }
-        )
-      end
-
-      -- Only assign after initialized.
-      active_clients[client_id] = client
-      -- If we had been registered before we start, then send didOpen This can
-      -- happen if we attach to buffers before initialize finishes or if
-      -- someone restarts a client.
-      for bufnr, client_ids in pairs(all_buffer_active_clients) do
-        if client_ids[client_id] then
-          client._on_attach(bufnr)
-        end
-      end
-    end)
-  end
-
-  ---@nodoc
-  --- Sends a request to the server.
-  ---
-  --- This is a thin wrapper around {client.rpc.request} with some additional
-  --- checks for capabilities and handler availability.
-  ---
-  ---@param method string LSP method name.
-  ---@param params table|nil LSP request params.
-  ---@param handler lsp.Handler|nil Response |lsp-handler| for this method.
-  ---@param bufnr integer Buffer handle (0 for current).
-  ---@return boolean status, integer|nil request_id {status} is a bool indicating
-  ---whether the request was successful. If it is `false`, then it will
-  ---always be `false` (the client has shutdown). If it was
-  ---successful, then it will return {request_id} as the
-  ---second result. You can use this with `client.cancel_request(request_id)`
-  ---to cancel the-request.
-  ---@see |vim.lsp.buf_request_all()|
-  function client.request(method, params, handler, bufnr)
-    if not handler then
-      handler = assert(
-        resolve_handler(method),
-        string.format('not found: %q request handler for client %q.', method, client.name)
-      )
-    end
-    -- Ensure pending didChange notifications are sent so that the server doesn't operate on a stale state
-    changetracking.flush(client, bufnr)
-    local version = util.buf_versions[bufnr]
-    bufnr = resolve_bufnr(bufnr)
-    if log.debug() then
-      log.debug(log_prefix, 'client.request', client_id, method, params, handler, bufnr)
-    end
-    local success, request_id = rpc.request(method, params, function(err, result)
-      local context = {
-        method = method,
-        client_id = client_id,
-        bufnr = bufnr,
-        params = params,
-        version = version,
-      }
-      handler(err, result, context)
-    end, function(request_id)
-      local request = client.requests[request_id]
-      request.type = 'complete'
-      nvim_exec_autocmds('LspRequest', {
-        buffer = api.nvim_buf_is_valid(bufnr) and bufnr or nil,
-        modeline = false,
-        data = { client_id = client_id, request_id = request_id, request = request },
-      })
-      client.requests[request_id] = nil
-    end)
-
-    if success and request_id then
-      local request = { type = 'pending', bufnr = bufnr, method = method }
-      client.requests[request_id] = request
-      nvim_exec_autocmds('LspRequest', {
-        buffer = bufnr,
-        modeline = false,
-        data = { client_id = client_id, request_id = request_id, request = request },
-      })
-    end
-
-    return success, request_id
-  end
-
-  ---@private
-  --- Sends a request to the server and synchronously waits for the response.
-  ---
-  --- This is a wrapper around {client.request}
-  ---
-  ---@param method (string) LSP method name.
-  ---@param params (table) LSP request params.
-  ---@param timeout_ms (integer|nil) Maximum time in milliseconds to wait for
-  ---                               a result. Defaults to 1000
-  ---@param bufnr (integer) Buffer handle (0 for current).
-  ---@return {err: lsp.ResponseError|nil, result:any}|nil, string|nil err # a dictionary, where
-  --- `err` and `result` come from the |lsp-handler|.
-  --- On timeout, cancel or error, returns `(nil, err)` where `err` is a
-  --- string describing the failure reason. If the request was unsuccessful
-  --- returns `nil`.
-  ---@see |vim.lsp.buf_request_sync()|
-  function client.request_sync(method, params, timeout_ms, bufnr)
-    local request_result = nil
-    local function _sync_handler(err, result)
-      request_result = { err = err, result = result }
-    end
-
-    local success, request_id = client.request(method, params, _sync_handler, bufnr)
-    if not success then
-      return nil
-    end
-
-    local wait_result, reason = vim.wait(timeout_ms or 1000, function()
-      return request_result ~= nil
-    end, 10)
-
-    if not wait_result then
-      if request_id then
-        client.cancel_request(request_id)
-      end
-      return nil, wait_result_reason[reason]
-    end
-    return request_result
-  end
-
-  ---@nodoc
-  --- Sends a notification to an LSP server.
-  ---
-  ---@param method string LSP method name.
-  ---@param params table|nil LSP request params.
-  ---@return boolean status true if the notification was successful.
-  ---If it is false, then it will always be false
-  ---(the client has shutdown).
-  function client.notify(method, params)
-    if method ~= ms.textDocument_didChange then
-      changetracking.flush(client)
-    end
-
-    local client_active = rpc.notify(method, params)
-
-    if client_active then
-      vim.schedule(function()
-        nvim_exec_autocmds('LspNotify', {
-          modeline = false,
-          data = {
-            client_id = client.id,
-            method = method,
-            params = params,
-          },
-        })
-      end)
-    end
-
-    return client_active
-  end
-
-  ---@nodoc
-  --- Cancels a request with a given request id.
-  ---
-  ---@param id (integer) id of request to cancel
-  ---@return boolean status true if notification was successful. false otherwise
-  ---@see |vim.lsp.client.notify()|
-  function client.cancel_request(id)
-    validate({ id = { id, 'n' } })
-    local request = client.requests[id]
-    if request and request.type == 'pending' then
-      request.type = 'cancel'
-      nvim_exec_autocmds('LspRequest', {
-        buffer = request.bufnr,
-        modeline = false,
-        data = { client_id = client_id, request_id = id, request = request },
-      })
-    end
-    return rpc.notify(ms.dollar_cancelRequest, { id = id })
-  end
-
-  -- Track this so that we can escalate automatically if we've already tried a
-  -- graceful shutdown
-  local graceful_shutdown_failed = false
-
-  ---@nodoc
-  --- 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.
-  ---
-  ---@param force boolean|nil
-  function client.stop(force)
-    if rpc.is_closing() then
-      return
-    end
-    if force or not client.initialized or graceful_shutdown_failed then
-      rpc.terminate()
-      return
-    end
-    -- Sending a signal after a process has exited is acceptable.
-    rpc.request(ms.shutdown, nil, function(err, _)
-      if err == nil then
-        rpc.notify(ms.exit)
-      else
-        -- If there was an error in the shutdown request, then term to be safe.
-        rpc.terminate()
-        graceful_shutdown_failed = true
-      end
-    end)
-  end
-
-  ---@private
-  --- Checks whether a client is stopped.
-  ---
-  ---@return boolean # true if client is stopped or in the process of being
-  ---stopped; false otherwise
-  function client.is_stopped()
-    return rpc.is_closing()
-  end
-
-  ---@private
-  --- Execute a lsp command, either via client command function (if available)
-  --- or via workspace/executeCommand (if supported by the server)
-  ---
-  ---@param command lsp.Command
-  ---@param context? {bufnr: integer}
-  ---@param handler? lsp.Handler only called if a server command
-  function client._exec_cmd(command, context, handler)
-    context = vim.deepcopy(context or {}, true) --[[@as lsp.HandlerContext]]
-    context.bufnr = context.bufnr or api.nvim_get_current_buf()
-    context.client_id = client.id
-    local cmdname = command.command
-    local fn = client.commands[cmdname] or lsp.commands[cmdname]
-    if fn then
-      fn(command, context)
-      return
-    end
-
-    local command_provider = client.server_capabilities.executeCommandProvider
-    local commands = type(command_provider) == 'table' and command_provider.commands or {}
-    if not vim.list_contains(commands, cmdname) then
-      vim.notify_once(
-        string.format(
-          'Language server `%s` does not support command `%s`. This command may require a client extension.',
-          client.name,
-          cmdname
-        ),
-        vim.log.levels.WARN
-      )
-      return
-    end
-    -- Not using command directly to exclude extra properties,
-    -- see https://github.com/python-lsp/python-lsp-server/issues/146
-    local params = {
-      command = command.command,
-      arguments = command.arguments,
-    }
-    client.request(ms.workspace_executeCommand, params, handler, context.bufnr)
-  end
-
-  ---@private
-  --- Runs the on_attach function from the client's config if it was defined.
-  ---@param bufnr integer Buffer number
-  function client._on_attach(bufnr)
-    text_document_did_open_handler(bufnr, client)
-
-    lsp._set_defaults(client, bufnr)
-
-    nvim_exec_autocmds('LspAttach', {
-      buffer = bufnr,
-      modeline = false,
-      data = { client_id = client.id },
-    })
-
-    if config.on_attach then
-      local status, err = pcall(config.on_attach, client, bufnr)
-      if not status then
-        write_error(lsp.client_errors.ON_ATTACH_ERROR, err)
+  client:initialize(function()
+    uninitialized_clients[client_id] = nil
+    -- Only assign after initialized.
+    active_clients[client_id] = client
+    -- If we had been registered before we start, then send didOpen This can
+    -- happen if we attach to buffers before initialize finishes or if
+    -- someone restarts a client.
+    for bufnr, client_ids in pairs(all_buffer_active_clients) do
+      if client_ids[client_id] then
+        client.on_attach(bufnr)
       end
     end
-
-    -- schedule the initialization of semantic tokens to give the above
-    -- on_attach and LspAttach callbacks the ability to schedule wrap the
-    -- opt-out (deleting the semanticTokensProvider from capabilities)
-    vim.schedule(function()
-      if vim.tbl_get(client.server_capabilities, 'semanticTokensProvider', 'full') then
-        lsp.semantic_tokens.start(bufnr, client.id)
-      end
-    end)
-
-    client.attached_buffers[bufnr] = true
-  end
-
-  initialize()
+  end)
 
   return client_id
 end
@@ -1564,7 +1101,7 @@ function lsp.buf_attach_client(bufnr, client_id)
           if vim.tbl_get(client.server_capabilities, 'textDocumentSync', 'openClose') then
             client.notify(ms.textDocument_didClose, params)
           end
-          text_document_did_open_handler(bufnr, client)
+          client:_text_document_did_open_handler(bufnr)
         end
       end,
       on_detach = function()
@@ -1596,7 +1133,7 @@ function lsp.buf_attach_client(bufnr, client_id)
   -- Send didOpen for the client if it is initialized. If it isn't initialized
   -- then it will send didOpen on initialize.
   if client then
-    client._on_attach(bufnr)
+    client:_on_attach(bufnr)
   end
   return true
 end
-- 
cgit 


From 1f9da3d0835af2cfe937de250c2cde3a59e1677e Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Thu, 8 Feb 2024 09:24:47 +0000
Subject: refactor(lsp): tidy up logging

---
 runtime/lua/vim/lsp.lua | 32 ++++++++------------------------
 1 file changed, 8 insertions(+), 24 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index dc50ab0267..7d8b7e50a3 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -798,9 +798,7 @@ function lsp.start_client(config)
   ---@param method (string) LSP method name
   ---@param params (table) The parameters for that method.
   function dispatch.notification(method, params)
-    if log.trace() then
-      log.trace('notification', method, params)
-    end
+    log.trace('notification', method, params)
     local handler = resolve_handler(method)
     if handler then
       -- Method name is provided here for convenience.
@@ -816,19 +814,13 @@ function lsp.start_client(config)
   ---@return any result
   ---@return lsp.ResponseError error code and message set in case an exception happens during the request.
   function dispatch.server_request(method, params)
-    if log.trace() then
-      log.trace('server_request', method, params)
-    end
+    log.trace('server_request', method, params)
     local handler = resolve_handler(method)
     if handler then
-      if log.trace() then
-        log.trace('server_request: found handler for', method)
-      end
+      log.trace('server_request: found handler for', method)
       return handler(nil, params, { method = method, client_id = client_id })
     end
-    if log.warn() then
-      log.warn('server_request: no handler found for', method)
-    end
+    log.warn('server_request: no handler found for', method)
     return nil, lsp.rpc_response_error(protocol.ErrorCodes.MethodNotFound)
   end
 
@@ -836,9 +828,7 @@ function lsp.start_client(config)
   --- @param code integer Error code
   --- @param err any Error arguments
   local function write_error(code, err)
-    if log.error() then
-      log.error(log_prefix, 'on_error', { code = lsp.client_errors[code], err = err })
-    end
+    log.error(log_prefix, 'on_error', { code = lsp.client_errors[code], err = err })
     err_message(log_prefix, ': Error ', lsp.client_errors[code], ': ', vim.inspect(err))
   end
 
@@ -854,9 +844,7 @@ function lsp.start_client(config)
     if config.on_error then
       local status, usererr = pcall(config.on_error, code, err)
       if not status then
-        if log.error() then
-          log.error(log_prefix, 'user on_error failed', { err = usererr })
-        end
+        log.error(log_prefix, 'user on_error failed', { err = usererr })
         err_message(log_prefix, ' user on_error failed: ', tostring(usererr))
       end
     end
@@ -1042,9 +1030,7 @@ function lsp.buf_attach_client(bufnr, client_id)
   })
   bufnr = resolve_bufnr(bufnr)
   if not api.nvim_buf_is_loaded(bufnr) then
-    if log.warn() then
-      log.warn(string.format('buf_attach_client called on unloaded buffer (id: %d): ', bufnr))
-    end
+    log.warn(string.format('buf_attach_client called on unloaded buffer (id: %d): ', bufnr))
     return false
   end
   local buffer_client_ids = all_buffer_active_clients[bufnr]
@@ -1504,9 +1490,7 @@ end
 --- - findstart=0: column where the completion starts, or -2 or -3
 --- - findstart=1: list of matches (actually just calls |complete()|)
 function lsp.omnifunc(findstart, base)
-  if log.debug() then
-    log.debug('omnifunc.findstart', { findstart = findstart, base = base })
-  end
+  log.debug('omnifunc.findstart', { findstart = findstart, base = base })
   return vim.lsp._completion.omnifunc(findstart, base)
 end
 
-- 
cgit 


From ed1b66bd998b98ee8cf76b5a23c323352588dd56 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Sun, 11 Feb 2024 12:37:20 +0000
Subject: refactor(lsp): move more code to client.lua

The dispatchers used by the RPC client should be defined in the client,
so they have been moved there. Due to this, it also made sense to move
all code related to client configuration and the creation of the RPC
client there too.

Now vim.lsp.start_client is significantly simplified and now mostly
contains logic for tracking open clients.

- Renamed client.new -> client.start
---
 runtime/lua/vim/lsp.lua | 475 +++++++++++-------------------------------------
 1 file changed, 107 insertions(+), 368 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 7d8b7e50a3..13f2c92cc2 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1,8 +1,4 @@
----@diagnostic disable: invisible
 local api = vim.api
-local nvim_err_writeln, nvim_buf_get_lines, nvim_command, nvim_exec_autocmds =
-  api.nvim_err_writeln, api.nvim_buf_get_lines, api.nvim_command, api.nvim_exec_autocmds
-local uv = vim.uv
 local tbl_isempty, tbl_extend = vim.tbl_isempty, vim.tbl_extend
 local validate = vim.validate
 local if_nil = vim.F.if_nil
@@ -71,14 +67,6 @@ lsp._request_name_to_capability = {
 
 -- TODO improve handling of scratch buffers with LSP attached.
 
---- Concatenates and writes a list of strings to the Vim error buffer.
----
----@param ... string List to write to the buffer
-local function err_message(...)
-  nvim_err_writeln(table.concat(vim.tbl_flatten({ ... })))
-  nvim_command('redraw')
-end
-
 --- Returns the buffer number for the given {bufnr}.
 ---
 ---@param bufnr (integer|nil) Buffer number to resolve. Defaults to current buffer
@@ -104,30 +92,8 @@ function lsp._unsupported_method(method)
   return msg
 end
 
---- Checks whether a given path is a directory.
----
----@param filename (string) path to check
----@return boolean # true if {filename} exists and is a directory, false otherwise
-local function is_dir(filename)
-  validate({ filename = { filename, 's' } })
-  local stat = uv.fs_stat(filename)
-  return stat and stat.type == 'directory' or false
-end
-
 local wait_result_reason = { [-1] = 'timeout', [-2] = 'interrupted', [-3] = 'error' }
 
-local valid_encodings = {
-  ['utf-8'] = 'utf-8',
-  ['utf-16'] = 'utf-16',
-  ['utf-32'] = 'utf-32',
-  ['utf8'] = 'utf-8',
-  ['utf16'] = 'utf-16',
-  ['utf32'] = 'utf-32',
-  UTF8 = 'utf-8',
-  UTF16 = 'utf-16',
-  UTF32 = 'utf-32',
-}
-
 local format_line_ending = {
   ['unix'] = '\n',
   ['dos'] = '\r\n',
@@ -141,14 +107,6 @@ function lsp._buf_get_line_ending(bufnr)
   return format_line_ending[vim.bo[bufnr].fileformat] or '\n'
 end
 
-local client_index = 0
---- Returns a new, unused client id.
----
----@return integer client_id
-local function next_client_id()
-  client_index = client_index + 1
-  return client_index
-end
 -- Tracks all clients created via lsp.start_client
 local active_clients = {} --- @type table<integer,lsp.Client>
 local all_buffer_active_clients = {} --- @type table<integer,table<integer,true>>
@@ -199,115 +157,6 @@ lsp.client_errors = tbl_extend(
   })
 )
 
---- Normalizes {encoding} to valid LSP encoding names.
----
----@param encoding (string) Encoding to normalize
----@return string # normalized encoding name
-local function validate_encoding(encoding)
-  validate({
-    encoding = { encoding, 's' },
-  })
-  return valid_encodings[encoding:lower()]
-    or error(
-      string.format(
-        "Invalid offset encoding %q. Must be one of: 'utf-8', 'utf-16', 'utf-32'",
-        encoding
-      )
-    )
-end
-
----@internal
---- Parses a command invocation into the command itself and its args. If there
---- are no arguments, an empty table is returned as the second argument.
----
----@param input string[]
----@return string command, string[] args #the command and arguments
-function lsp._cmd_parts(input)
-  validate({
-    cmd = {
-      input,
-      function()
-        return vim.tbl_islist(input)
-      end,
-      'list',
-    },
-  })
-
-  local cmd = input[1]
-  local cmd_args = {}
-  -- Don't mutate our input.
-  for i, v in ipairs(input) do
-    validate({ ['cmd argument'] = { v, 's' } })
-    if i > 1 then
-      table.insert(cmd_args, v)
-    end
-  end
-  return cmd, cmd_args
-end
-
---- Augments a validator function with support for optional (nil) values.
----
----@param fn (fun(v): boolean) The original validator function; should return a
----bool.
----@return fun(v): boolean # The augmented function. Also returns true if {v} is
----`nil`.
-local function optional_validator(fn)
-  return function(v)
-    return v == nil or fn(v)
-  end
-end
-
---- Validates a client configuration as given to |vim.lsp.start_client()|.
----
----@param config (lsp.ClientConfig)
----@return (string|fun(dispatchers:vim.lsp.rpc.Dispatchers):vim.lsp.rpc.PublicClient?) Command
----@return string[] Arguments
----@return string Encoding.
-local function validate_client_config(config)
-  validate({
-    config = { config, 't' },
-  })
-  validate({
-    handlers = { config.handlers, 't', true },
-    capabilities = { config.capabilities, 't', true },
-    cmd_cwd = { config.cmd_cwd, optional_validator(is_dir), 'directory' },
-    cmd_env = { config.cmd_env, 't', true },
-    detached = { config.detached, 'b', true },
-    name = { config.name, 's', true },
-    on_error = { config.on_error, 'f', true },
-    on_exit = { config.on_exit, 'f', true },
-    on_init = { config.on_init, 'f', true },
-    settings = { config.settings, 't', true },
-    commands = { config.commands, 't', true },
-    before_init = { config.before_init, 'f', true },
-    offset_encoding = { config.offset_encoding, 's', true },
-    flags = { config.flags, 't', true },
-    get_language_id = { config.get_language_id, 'f', true },
-  })
-  assert(
-    (
-      not config.flags
-      or not config.flags.debounce_text_changes
-      or type(config.flags.debounce_text_changes) == 'number'
-    ),
-    'flags.debounce_text_changes must be a number with the debounce time in milliseconds'
-  )
-
-  local cmd, cmd_args --- @type (string|fun(dispatchers:vim.lsp.rpc.Dispatchers):vim.lsp.rpc.PublicClient), string[]
-  local config_cmd = config.cmd
-  if type(config_cmd) == 'function' then
-    cmd = config_cmd
-  else
-    cmd, cmd_args = lsp._cmd_parts(config_cmd)
-  end
-  local offset_encoding = valid_encodings.UTF16
-  if config.offset_encoding then
-    offset_encoding = validate_encoding(config.offset_encoding)
-  end
-
-  return cmd, cmd_args, offset_encoding
-end
-
 ---@private
 --- Returns full text of buffer {bufnr} as a string.
 ---
@@ -315,7 +164,7 @@ end
 ---@return string # Buffer text as string.
 function lsp._buf_get_full_text(bufnr)
   local line_ending = lsp._buf_get_line_ending(bufnr)
-  local text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, true), line_ending)
+  local text = table.concat(api.nvim_buf_get_lines(bufnr, 0, -1, true), line_ending)
   if vim.bo[bufnr].eol then
     text = text .. line_ending
   end
@@ -473,8 +322,8 @@ end
 --- Either use |:au|, |nvim_create_autocmd()| or put the call in a
 --- `ftplugin/<filetype_name>.lua` (See |ftplugin-name|)
 ---
----@param config table Same configuration as documented in |vim.lsp.start_client()|
----@param opts (nil|lsp.StartOpts) Optional keyword arguments:
+---@param config lsp.ClientConfig Same configuration as documented in |vim.lsp.start_client()|
+---@param opts lsp.StartOpts? Optional keyword arguments:
 ---             - reuse_client (fun(client: client, config: table): boolean)
 ---                            Predicate used to decide if a client should be re-used.
 ---                            Used on all running clients.
@@ -483,20 +332,16 @@ end
 ---             - bufnr (number)
 ---                     Buffer handle to attach to if starting or re-using a
 ---                     client (0 for current).
----@return integer|nil client_id
+---@return integer? client_id
 function lsp.start(config, opts)
   opts = opts or {}
   local reuse_client = opts.reuse_client
     or function(client, conf)
       return client.config.root_dir == conf.root_dir and client.name == conf.name
     end
-  if not config.name and type(config.cmd) == 'table' then
-    config.name = config.cmd[1] and vim.fs.basename(config.cmd[1]) or nil
-  end
-  local bufnr = opts.bufnr
-  if bufnr == nil or bufnr == 0 then
-    bufnr = api.nvim_get_current_buf()
-  end
+
+  local bufnr = resolve_bufnr(opts.bufnr)
+
   for _, clients in ipairs({ uninitialized_clients, lsp.get_clients() }) do
     for _, client in pairs(clients) do
       if reuse_client(client, config) then
@@ -505,10 +350,13 @@ function lsp.start(config, opts)
       end
     end
   end
+
   local client_id = lsp.start_client(config)
-  if client_id == nil then
-    return nil -- lsp.start_client will have printed an error
+
+  if not client_id then
+    return -- lsp.start_client will have printed an error
   end
+
   lsp.buf_attach_client(bufnr, client_id)
   return client_id
 end
@@ -599,29 +447,6 @@ function lsp._set_defaults(client, bufnr)
   end
 end
 
---- @class lsp.ClientConfig
---- @field cmd (string[]|fun(dispatchers: table):table)
---- @field cmd_cwd string
---- @field cmd_env (table)
---- @field detached boolean
---- @field workspace_folders (table)
---- @field capabilities lsp.ClientCapabilities
---- @field handlers table<string,function>
---- @field settings table
---- @field commands table
---- @field init_options table
---- @field name string
---- @field get_language_id fun(bufnr: integer, filetype: string): string
---- @field offset_encoding string
---- @field on_error fun(code: integer)
---- @field before_init function
---- @field on_init function
---- @field on_exit fun(code: integer, signal: integer, client_id: integer)
---- @field on_attach fun(client: lsp.Client, bufnr: integer)
---- @field trace 'off'|'messages'|'verbose'|nil
---- @field flags table
---- @field root_dir string
-
 --- Reset defaults set by `set_defaults`.
 --- Must only be called if the last client attached to a buffer exits.
 local function reset_defaults(bufnr)
@@ -642,6 +467,90 @@ local function reset_defaults(bufnr)
   end)
 end
 
+--- @param client lsp.Client
+local function on_client_init(client)
+  local id = client.id
+  uninitialized_clients[id] = nil
+  -- Only assign after initialized.
+  active_clients[id] = client
+  -- If we had been registered before we start, then send didOpen This can
+  -- happen if we attach to buffers before initialize finishes or if
+  -- someone restarts a client.
+  for bufnr, client_ids in pairs(all_buffer_active_clients) do
+    if client_ids[id] then
+      client.on_attach(bufnr)
+    end
+  end
+end
+
+--- @param code integer
+--- @param signal integer
+--- @param client_id integer
+local function on_client_exit(code, signal, client_id)
+  local client = active_clients[client_id] or uninitialized_clients[client_id]
+
+  for bufnr, client_ids in pairs(all_buffer_active_clients) do
+    if client_ids[client_id] then
+      vim.schedule(function()
+        if client and client.attached_buffers[bufnr] then
+          api.nvim_exec_autocmds('LspDetach', {
+            buffer = bufnr,
+            modeline = false,
+            data = { client_id = client_id },
+          })
+        end
+
+        local namespace = vim.lsp.diagnostic.get_namespace(client_id)
+        vim.diagnostic.reset(namespace, bufnr)
+
+        client_ids[client_id] = nil
+        if vim.tbl_isempty(client_ids) then
+          reset_defaults(bufnr)
+        end
+      end)
+    end
+  end
+
+  local name = client.name or 'unknown'
+
+  -- Schedule the deletion of the client object so that it exists in the execution of LspDetach
+  -- autocommands
+  vim.schedule(function()
+    active_clients[client_id] = nil
+    uninitialized_clients[client_id] = nil
+
+    -- Client can be absent if executable starts, but initialize fails
+    -- init/attach won't have happened
+    if client then
+      changetracking.reset(client)
+    end
+    if code ~= 0 or (signal ~= 0 and signal ~= 15) then
+      local msg = string.format(
+        'Client %s quit with exit code %s and signal %s. Check log for errors: %s',
+        name,
+        code,
+        signal,
+        lsp.get_log_path()
+      )
+      vim.notify(msg, vim.log.levels.WARN)
+    end
+  end)
+end
+
+--- @generic F: function
+--- @param ... F
+--- @return F
+local function join_cbs(...)
+  local funcs = vim.F.pack_len(...)
+  return function(...)
+    for i = 1, funcs.n do
+      if funcs[i] ~= nil then
+        funcs[i](...)
+      end
+    end
+  end
+end
+
 -- FIXME: DOC: Currently all methods on the `vim.lsp.client` object are
 -- documented twice: Here, and on the methods themselves (e.g.
 -- `client.request()`). This is a workaround for the vimdoc generator script
@@ -762,192 +671,22 @@ end
 --- fully initialized. Use `on_init` to do any actions once
 --- the client has been initialized.
 function lsp.start_client(config)
-  local cmd, cmd_args, offset_encoding = validate_client_config(config)
-
-  config.flags = config.flags or {}
-  config.settings = config.settings or {}
-
-  -- By default, get_language_id just returns the exact filetype it is passed.
-  --    It is possible to pass in something that will calculate a different filetype,
-  --    to be sent by the client.
-  config.get_language_id = config.get_language_id or function(_, filetype)
-    return filetype
-  end
-
-  local client_id = next_client_id()
-
-  local handlers = config.handlers or {}
-  local name = config.name or tostring(client_id)
-  local log_prefix = string.format('LSP[%s]', name)
-
-  local dispatch = {}
-
-  --- Returns the handler associated with an LSP method.
-  --- Returns the default handler if the user hasn't set a custom one.
-  ---
-  ---@param method (string) LSP method name
-  ---@return lsp.Handler|nil handler for the given method, if defined, or the default from |vim.lsp.handlers|
-  local function resolve_handler(method)
-    return handlers[method] or lsp.handlers[method]
-  end
-
-  ---@private
-  --- Handles a notification sent by an LSP server by invoking the
-  --- corresponding handler.
-  ---
-  ---@param method (string) LSP method name
-  ---@param params (table) The parameters for that method.
-  function dispatch.notification(method, params)
-    log.trace('notification', method, params)
-    local handler = resolve_handler(method)
-    if handler then
-      -- Method name is provided here for convenience.
-      handler(nil, params, { method = method, client_id = client_id })
-    end
-  end
+  config = vim.deepcopy(config, false)
+  config.on_init = join_cbs(config.on_init, on_client_init)
+  config.on_exit = join_cbs(config.on_exit, on_client_exit)
 
-  ---@private
-  --- Handles a request from an LSP server by invoking the corresponding handler.
-  ---
-  ---@param method (string) LSP method name
-  ---@param params (table) The parameters for that method
-  ---@return any result
-  ---@return lsp.ResponseError error code and message set in case an exception happens during the request.
-  function dispatch.server_request(method, params)
-    log.trace('server_request', method, params)
-    local handler = resolve_handler(method)
-    if handler then
-      log.trace('server_request: found handler for', method)
-      return handler(nil, params, { method = method, client_id = client_id })
-    end
-    log.warn('server_request: no handler found for', method)
-    return nil, lsp.rpc_response_error(protocol.ErrorCodes.MethodNotFound)
-  end
-
-  --- Logs the given error to the LSP log and to the error buffer.
-  --- @param code integer Error code
-  --- @param err any Error arguments
-  local function write_error(code, err)
-    log.error(log_prefix, 'on_error', { code = lsp.client_errors[code], err = err })
-    err_message(log_prefix, ': Error ', lsp.client_errors[code], ': ', vim.inspect(err))
-  end
+  local client = require('vim.lsp.client').start(config)
 
-  ---@private
-  --- Invoked when the client operation throws an error.
-  ---
-  ---@param code (integer) Error code
-  ---@param err any 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 a human-friendly name.
-  function dispatch.on_error(code, err)
-    write_error(code, err)
-    if config.on_error then
-      local status, usererr = pcall(config.on_error, code, err)
-      if not status then
-        log.error(log_prefix, 'user on_error failed', { err = usererr })
-        err_message(log_prefix, ' user on_error failed: ', tostring(usererr))
-      end
-    end
-  end
-
-  ---@private
-  --- Invoked on client exit.
-  ---
-  ---@param code (integer) exit code of the process
-  ---@param signal (integer) the signal used to terminate (if any)
-  function dispatch.on_exit(code, signal)
-    if config.on_exit then
-      pcall(config.on_exit, code, signal, client_id)
-    end
-
-    local client = active_clients[client_id] and active_clients[client_id]
-      or uninitialized_clients[client_id]
-
-    for bufnr, client_ids in pairs(all_buffer_active_clients) do
-      if client_ids[client_id] then
-        vim.schedule(function()
-          if client and client.attached_buffers[bufnr] then
-            nvim_exec_autocmds('LspDetach', {
-              buffer = bufnr,
-              modeline = false,
-              data = { client_id = client_id },
-            })
-          end
-
-          local namespace = vim.lsp.diagnostic.get_namespace(client_id)
-          vim.diagnostic.reset(namespace, bufnr)
-
-          client_ids[client_id] = nil
-          if vim.tbl_isempty(client_ids) then
-            reset_defaults(bufnr)
-          end
-        end)
-      end
-    end
-
-    -- Schedule the deletion of the client object so that it exists in the execution of LspDetach
-    -- autocommands
-    vim.schedule(function()
-      active_clients[client_id] = nil
-      uninitialized_clients[client_id] = nil
-
-      -- Client can be absent if executable starts, but initialize fails
-      -- init/attach won't have happened
-      if client then
-        changetracking.reset(client)
-      end
-      if code ~= 0 or (signal ~= 0 and signal ~= 15) then
-        local msg = string.format(
-          'Client %s quit with exit code %s and signal %s. Check log for errors: %s',
-          name,
-          code,
-          signal,
-          lsp.get_log_path()
-        )
-        vim.notify(msg, vim.log.levels.WARN)
-      end
-    end)
-  end
-
-  -- Start the RPC client.
-  local rpc --- @type vim.lsp.rpc.PublicClient?
-  if type(cmd) == 'function' then
-    rpc = cmd(dispatch)
-  else
-    rpc = lsp.rpc.start(cmd, cmd_args, dispatch, {
-      cwd = config.cmd_cwd,
-      env = config.cmd_env,
-      detached = config.detached,
-    })
-  end
-
-  -- Return nil if client fails to start
-  if not rpc then
+  if not client then
     return
   end
 
-  config.capabilities = config.capabilities or protocol.make_client_capabilities()
-
-  local client = require('vim.lsp.client').new(client_id, rpc, handlers, offset_encoding, config)
-
   -- Store the uninitialized_clients for cleanup in case we exit before initialize finishes.
-  uninitialized_clients[client_id] = client
+  -- TODO(lewis6991): do this on before_init(). Requires API change to before_init() so it
+  -- can access the client_id.
+  uninitialized_clients[client.id] = client
 
-  client:initialize(function()
-    uninitialized_clients[client_id] = nil
-    -- Only assign after initialized.
-    active_clients[client_id] = client
-    -- If we had been registered before we start, then send didOpen This can
-    -- happen if we attach to buffers before initialize finishes or if
-    -- someone restarts a client.
-    for bufnr, client_ids in pairs(all_buffer_active_clients) do
-      if client_ids[client_id] then
-        client.on_attach(bufnr)
-      end
-    end
-  end)
-
-  return client_id
+  return client.id
 end
 
 --- Notify all attached clients that a buffer has changed.
@@ -1149,7 +888,7 @@ function lsp.buf_detach_client(bufnr, client_id)
     return
   end
 
-  nvim_exec_autocmds('LspDetach', {
+  api.nvim_exec_autocmds('LspDetach', {
     buffer = bufnr,
     modeline = false,
     data = { client_id = client_id },
@@ -1372,7 +1111,7 @@ function lsp.buf_request(bufnr, method, params, handler)
   -- if has client but no clients support the given method, notify the user
   if next(clients) and not method_supported then
     vim.notify(lsp._unsupported_method(method), vim.log.levels.ERROR)
-    nvim_command('redraw')
+    vim.cmd.redraw()
     return {}, function() end
   end
 
-- 
cgit 


From 9f8c96240dc0318bd92a646966917e8fe0641144 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Mon, 12 Feb 2024 13:46:32 +0000
Subject: refactor(lsp): resolve the config-client entanglement

Previously the LSP-Client object contained some fields that are also
in the client config, but for a lot of other fields, the config was used
directly making the two objects vaguely entangled with either not having
a clear role.

Now the config object is treated purely as config (read-only) from the
client, and any fields the client needs from the config are now copied
in as additional fields.

This means:
- the config object is no longet normalised and is left as the user
  provided it.
- the client only reads the config on creation of the client and all
  other implementations now read the clients version of the fields.

In addition, internal support for multiple callbacks has been added to
the client so the client tracking logic (done in lua.lsp) can be done
more robustly instead of wrapping the user callbacks which may error.
---
 runtime/lua/vim/lsp.lua | 61 ++++++++++++++++++++++++++-----------------------
 1 file changed, 33 insertions(+), 28 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 13f2c92cc2..8608bdfa57 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -143,6 +143,14 @@ local function for_each_buffer_client(bufnr, fn, restrict_client_ids)
   end
 end
 
+local client_errors_base = table.maxn(lsp.rpc.client_errors)
+local client_errors_offset = 0
+
+local function new_error_index()
+  client_errors_offset = client_errors_offset + 1
+  return client_errors_base + client_errors_offset
+end
+
 --- 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.
@@ -151,9 +159,10 @@ lsp.client_errors = tbl_extend(
   'error',
   lsp.rpc.client_errors,
   vim.tbl_add_reverse_lookup({
-    BEFORE_INIT_CALLBACK_ERROR = table.maxn(lsp.rpc.client_errors) + 1,
-    ON_INIT_CALLBACK_ERROR = table.maxn(lsp.rpc.client_errors) + 2,
-    ON_ATTACH_ERROR = table.maxn(lsp.rpc.client_errors) + 3,
+    BEFORE_INIT_CALLBACK_ERROR = new_error_index(),
+    ON_INIT_CALLBACK_ERROR = new_error_index(),
+    ON_ATTACH_ERROR = new_error_index(),
+    ON_EXIT_CALLBACK_ERROR = new_error_index(),
   })
 )
 
@@ -262,6 +271,10 @@ end
 ---
 ---  - {handlers} (table): The handlers used by the client as described in |lsp-handler|.
 ---
+---  - {commands} (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.
+---
 ---  - {requests} (table): The current pending requests in flight
 ---    to the server. Entries are key-value pairs with the key
 ---    being the request ID while the value is a table with `type`,
@@ -270,7 +283,7 @@ end
 ---    be "complete" ephemerally while executing |LspRequest| autocmds
 ---    when replies are received from the server.
 ---
----  - {config} (table): copy of the table that was passed by the user
+---  - {config} (table): Reference of the table that was passed by the user
 ---    to |vim.lsp.start_client()|.
 ---
 ---  - {server_capabilities} (table): Response from the server sent on
@@ -278,6 +291,11 @@ end
 ---
 ---  - {progress} A ring buffer (|vim.ringbuf()|) containing progress messages
 ---    sent by the server.
+---
+---  - {settings} Map with language server specific settings.
+---    See {config} in |vim.lsp.start_client()|
+---
+---  - {flags} A table with flags for the client. See {config} in |vim.lsp.start_client()|
 function lsp.client()
   error()
 end
@@ -337,7 +355,7 @@ function lsp.start(config, opts)
   opts = opts or {}
   local reuse_client = opts.reuse_client
     or function(client, conf)
-      return client.config.root_dir == conf.root_dir and client.name == conf.name
+      return client.root_dir == conf.root_dir and client.name == conf.name
     end
 
   local bufnr = resolve_bufnr(opts.bufnr)
@@ -537,20 +555,6 @@ local function on_client_exit(code, signal, client_id)
   end)
 end
 
---- @generic F: function
---- @param ... F
---- @return F
-local function join_cbs(...)
-  local funcs = vim.F.pack_len(...)
-  return function(...)
-    for i = 1, funcs.n do
-      if funcs[i] ~= nil then
-        funcs[i](...)
-      end
-    end
-  end
-end
-
 -- FIXME: DOC: Currently all methods on the `vim.lsp.client` object are
 -- documented twice: Here, and on the methods themselves (e.g.
 -- `client.request()`). This is a workaround for the vimdoc generator script
@@ -671,21 +675,22 @@ end
 --- fully initialized. Use `on_init` to do any actions once
 --- the client has been initialized.
 function lsp.start_client(config)
-  config = vim.deepcopy(config, false)
-  config.on_init = join_cbs(config.on_init, on_client_init)
-  config.on_exit = join_cbs(config.on_exit, on_client_exit)
-
-  local client = require('vim.lsp.client').start(config)
+  local client = require('vim.lsp.client').create(config)
 
   if not client then
     return
   end
 
+  --- @diagnostic disable-next-line: invisible
+  table.insert(client._on_init_cbs, on_client_init)
+  --- @diagnostic disable-next-line: invisible
+  table.insert(client._on_exit_cbs, on_client_exit)
+
   -- Store the uninitialized_clients for cleanup in case we exit before initialize finishes.
-  -- TODO(lewis6991): do this on before_init(). Requires API change to before_init() so it
-  -- can access the client_id.
   uninitialized_clients[client.id] = client
 
+  client:initialize()
+
   return client.id
 end
 
@@ -732,7 +737,7 @@ local function text_document_did_save_handler(bufnr)
         textDocument = {
           version = 0,
           uri = uri,
-          languageId = client.config.get_language_id(bufnr, vim.bo[bufnr].filetype),
+          languageId = client.get_language_id(bufnr, vim.bo[bufnr].filetype),
           text = lsp._buf_get_full_text(bufnr),
         },
       })
@@ -1034,7 +1039,7 @@ api.nvim_create_autocmd('VimLeavePre', {
     local send_kill = false
 
     for client_id, client in pairs(active_clients) do
-      local timeout = if_nil(client.config.flags.exit_timeout, false)
+      local timeout = if_nil(client.flags.exit_timeout, false)
       if timeout then
         send_kill = true
         timeouts[client_id] = timeout
-- 
cgit 


From 15f7ac6a045aad3355e4c6006423fde81644886a Mon Sep 17 00:00:00 2001
From: Tim Pope <code@tpope.net>
Date: Sat, 24 Feb 2024 01:19:33 -0500
Subject: docs(lsp): remove obsolete didChangeConfiguration explanation
 (#27595)

Rendered obsolete by c6d747e6a5227e17556c62e16ed054398eb1a89a.
---
 runtime/lua/vim/lsp.lua | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 8608bdfa57..689d942d72 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -641,10 +641,7 @@ end
 ---       the server may send. For example, clangd sends
 ---       `initialize_result.offsetEncoding` if `capabilities.offsetEncoding` was
 ---       sent to it. You can only modify the `client.offset_encoding` here before
----       any notifications are sent. Most language servers expect to be sent client specified settings after
----       initialization. Nvim does not make this assumption. A
----       `workspace/didChangeConfiguration` notification should be sent
----        to the server during on_init.
+---       any notifications are sent.
 ---
 --- - on_exit Callback (code, signal, client_id) invoked on client
 --- exit.
-- 
cgit 


From 2e1f5055acdef650c27efc4afdf8606037ec021b Mon Sep 17 00:00:00 2001
From: Gregory Anders <8965202+gpanders@users.noreply.github.com>
Date: Sat, 24 Feb 2024 19:21:57 -0600
Subject: fix(lsp): add assertion for explicit bufnr in apply_text_edits
 (#27614)

Assert that the buffer number passed to apply_text_edits is fully
resolved (not 0 or null). Pass the known buffer number to
apply_text_edits from lsp.formatexpr().
---
 runtime/lua/vim/lsp.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 689d942d72..3a74c3ee90 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1280,7 +1280,7 @@ function lsp.formatexpr(opts)
       local response =
         client.request_sync(ms.textDocument_rangeFormatting, params, timeout_ms, bufnr)
       if response and response.result then
-        lsp.util.apply_text_edits(response.result, 0, client.offset_encoding)
+        lsp.util.apply_text_edits(response.result, bufnr, client.offset_encoding)
         return 0
       end
     end
-- 
cgit 


From 9beb40a4db5613601fc1a4b828a44e5977eca046 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Thu, 15 Feb 2024 17:16:04 +0000
Subject: feat(docs): replace lua2dox.lua

Problem:

The documentation flow (`gen_vimdoc.py`) has several issues:
- it's not very versatile
- depends on doxygen
- doesn't work well with Lua code as it requires an awkward filter script to convert it into pseudo-C.
- The intermediate XML files and filters makes it too much like a rube goldberg machine.

Solution:

Re-implement the flow using Lua, LPEG and treesitter.

- `gen_vimdoc.py` is now replaced with `gen_vimdoc.lua` and replicates a portion of the logic.
- `lua2dox.lua` is gone!
- No more XML files.
- Doxygen is now longer used and instead we now use:
  - LPEG for comment parsing (see `scripts/luacats_grammar.lua` and `scripts/cdoc_grammar.lua`).
  - LPEG for C parsing (see `scripts/cdoc_parser.lua`)
  - Lua patterns for Lua parsing (see `scripts/luacats_parser.lua`).
  - Treesitter for Markdown parsing (see `scripts/text_utils.lua`).
- The generated `runtime/doc/*.mpack` files have been removed.
   - `scripts/gen_eval_files.lua` now instead uses `scripts/cdoc_parser.lua` directly.
- Text wrapping is implemented in `scripts/text_utils.lua` and appears to produce more consistent results (the main contributer to the diff of this change).
---
 runtime/lua/vim/lsp.lua | 190 ++++++++++++++++++++++++------------------------
 1 file changed, 94 insertions(+), 96 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 3a74c3ee90..19497e40dc 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -206,99 +206,96 @@ end
 --- |vim.lsp.get_client_by_id()| or |vim.lsp.get_clients()|.
 ---
 --- - Methods:
----
----  - request(method, params, [handler], bufnr)
----     Sends a request to the server.
----     This is a thin wrapper around {client.rpc.request} with some additional
----     checking.
----     If {handler} is not specified,  If one is not found there, then an error will occur.
----     Returns: {status}, {[client_id]}. {status} is a boolean indicating if
----     the notification was successful. If it is `false`, then it will always
----     be `false` (the client has shutdown).
----     If {status} is `true`, the function returns {request_id} as the second
----     result. You can use this with `client.cancel_request(request_id)`
----     to cancel the request.
----
----  - request_sync(method, params, timeout_ms, bufnr)
----     Sends a request to the server and synchronously waits for the response.
----     This is a wrapper around {client.request}
----     Returns: { err=err, result=result }, a dictionary, where `err` and `result` come from
----     the |lsp-handler|. On timeout, cancel or error, returns `(nil, err)` where `err` is a
----     string describing the failure reason. If the request was unsuccessful returns `nil`.
----
----  - notify(method, params)
----     Sends a notification to an LSP server.
----     Returns: a boolean to indicate if the notification was successful. If
----     it is false, then it will always be false (the client has shutdown).
----
----  - cancel_request(id)
----     Cancels a request with a given request id.
----     Returns: same as `notify()`.
----
----  - stop([force])
----     Stops a client, optionally with force.
----     By default, it will just ask the server to shutdown without force.
----     If you request to stop a client which has previously been requested to
----     shutdown, it will automatically escalate and force shutdown.
----
----  - is_stopped()
----     Checks whether a client is stopped.
----     Returns: true if the client is fully stopped.
----
----  - on_attach(client, bufnr)
----     Runs the on_attach function from the client's config if it was defined.
----     Useful for buffer-local setup.
----
----  - supports_method(method, [opts]): 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.
+---   - request(method, params, [handler], bufnr)
+---      Sends a request to the server.
+---      This is a thin wrapper around {client.rpc.request} with some additional
+---      checking.
+---      If {handler} is not specified,  If one is not found there, then an error will occur.
+---      Returns: {status}, {[client_id]}. {status} is a boolean indicating if
+---      the notification was successful. If it is `false`, then it will always
+---      be `false` (the client has shutdown).
+---      If {status} is `true`, the function returns {request_id} as the second
+---      result. You can use this with `client.cancel_request(request_id)`
+---      to cancel the request.
+---
+---   - request_sync(method, params, timeout_ms, bufnr)
+---      Sends a request to the server and synchronously waits for the response.
+---      This is a wrapper around {client.request}
+---      Returns: { err=err, result=result }, a dictionary, where `err` and `result` come from
+---      the |lsp-handler|. On timeout, cancel or error, returns `(nil, err)` where `err` is a
+---      string describing the failure reason. If the request was unsuccessful returns `nil`.
+---
+---   - notify(method, params)
+---      Sends a notification to an LSP server.
+---      Returns: a boolean to indicate if the notification was successful. If
+---      it is false, then it will always be false (the client has shutdown).
+---
+---   - cancel_request(id)
+---      Cancels a request with a given request id.
+---      Returns: same as `notify()`.
+---
+---   - stop([force])
+---      Stops a client, optionally with force.
+---      By default, it will just ask the server to shutdown without force.
+---      If you request to stop a client which has previously been requested to
+---      shutdown, it will automatically escalate and force shutdown.
+---
+---   - is_stopped()
+---      Checks whether a client is stopped.
+---      Returns: true if the client is fully stopped.
+---
+---   - on_attach(client, bufnr)
+---      Runs the on_attach function from the client's config if it was defined.
+---      Useful for buffer-local setup.
+---
+---   - supports_method(method, [opts]): 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.
 ---
 --- - Members
----  - {id} (number): The id allocated to the client.
+---   - {id} (number): The id allocated to the client.
 ---
----  - {name} (string): If a name is specified on creation, that will be
----    used. Otherwise it is just the client id. This is used for
----    logs and messages.
+---   - {name} (string): If a name is specified on creation, that will be
+---     used. Otherwise it is just the client id. This is used for
+---     logs and messages.
 ---
----  - {rpc} (table): RPC client object, for low level interaction with the
----    client. See |vim.lsp.rpc.start()|.
+---   - {rpc} (table): RPC client object, for low level interaction with the
+---     client. See |vim.lsp.rpc.start()|.
 ---
----  - {offset_encoding} (string): The encoding used for communicating
----    with the server. You can modify this in the `config`'s `on_init` method
----    before text is sent to the server.
+---   - {offset_encoding} (string): The encoding used for communicating
+---     with the server. You can modify this in the `config`'s `on_init` method
+---     before text is sent to the server.
 ---
----  - {handlers} (table): The handlers used by the client as described in |lsp-handler|.
+---   - {handlers} (table): The handlers used by the client as described in |lsp-handler|.
 ---
----  - {commands} (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.
+---   - {commands} (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.
 ---
----  - {requests} (table): The current pending requests in flight
----    to the server. Entries are key-value pairs with the key
----    being the request ID while the value is a table with `type`,
----    `bufnr`, and `method` key-value pairs. `type` is either "pending"
----    for an active request, or "cancel" for a cancel request. It will
----    be "complete" ephemerally while executing |LspRequest| autocmds
----    when replies are received from the server.
+---   - {requests} (table): The current pending requests in flight
+---     to the server. Entries are key-value pairs with the key
+---     being the request ID while the value is a table with `type`,
+---     `bufnr`, and `method` key-value pairs. `type` is either "pending"
+---     for an active request, or "cancel" for a cancel request. It will
+---     be "complete" ephemerally while executing |LspRequest| autocmds
+---     when replies are received from the server.
 ---
----  - {config} (table): Reference of the table that was passed by the user
----    to |vim.lsp.start_client()|.
+---   - {config} (table): Reference of the table that was passed by the user
+---     to |vim.lsp.start_client()|.
 ---
----  - {server_capabilities} (table): Response from the server sent on
----    `initialize` describing the server's capabilities.
+---   - {server_capabilities} (table): Response from the server sent on
+---     `initialize` describing the server's capabilities.
 ---
----  - {progress} A ring buffer (|vim.ringbuf()|) containing progress messages
----    sent by the server.
+---   - {progress} A ring buffer (|vim.ringbuf()|) containing progress messages
+---     sent by the server.
 ---
----  - {settings} Map with language server specific settings.
----    See {config} in |vim.lsp.start_client()|
+---   - {settings} Map with language server specific settings.
+---     See {config} in |vim.lsp.start_client()|
 ---
----  - {flags} A table with flags for the client. See {config} in |vim.lsp.start_client()|
-function lsp.client()
-  error()
-end
+---   - {flags} A table with flags for the client. See {config} in |vim.lsp.start_client()|
+lsp.client = nil
 
 --- @class lsp.StartOpts
 --- @field reuse_client fun(client: lsp.Client, config: table): boolean
@@ -581,9 +578,9 @@ end
 ---       spawn.  Must be specified using a table.
 ---       Non-string values are coerced to string.
 ---       Example:
----       <pre>
----                   { PORT = 8080; HOST = "0.0.0.0"; }
----       </pre>
+---    ```
+---        { 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
@@ -598,8 +595,9 @@ end
 ---       \|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.
+---
+---     - Note: To send an empty dictionary use |vim.empty_dict()|, else it will be encoded as an
+---       array.
 ---
 --- - handlers: Map of language server method names to |lsp-handler|
 ---
@@ -645,9 +643,9 @@ end
 ---
 --- - on_exit Callback (code, signal, client_id) invoked on client
 --- exit.
----       - code: exit code of the process
----       - signal: number describing the signal used to terminate (if any)
----       - client_id: client handle
+---   - code: exit code of the process
+---   - signal: number describing the signal used to terminate (if any)
+---   - client_id: client handle
 ---
 --- - on_attach: Callback (client, bufnr) invoked when client
 ---       attaches to a buffer.
@@ -656,13 +654,13 @@ end
 ---       server in the initialize request. Invalid/empty values will default to "off"
 ---
 --- - flags: A table with flags for the client. The current (experimental) flags are:
----       - allow_incremental_sync (bool, default true): Allow using incremental sync for buffer edits
----       - debounce_text_changes (number, default 150): Debounce didChange
----             notifications to the server by the given number in milliseconds. No debounce
----             occurs if nil
----       - exit_timeout (number|boolean, default false): Milliseconds to wait for server to
----             exit cleanly after sending the "shutdown" request before sending kill -15.
----             If set to false, nvim exits immediately after sending the "shutdown" request to the server.
+---   - allow_incremental_sync (bool, default true): Allow using incremental sync for buffer edits
+---   - debounce_text_changes (number, default 150): Debounce didChange
+---         notifications to the server by the given number in milliseconds. No debounce
+---         occurs if nil
+---   - exit_timeout (number|boolean, default false): Milliseconds to wait for server to
+---         exit cleanly after sending the "shutdown" request before sending kill -15.
+---         If set to false, nvim exits immediately after sending the "shutdown" request to the server.
 ---
 --- - root_dir: (string) Directory where the LSP
 ---       server will base its workspaceFolders, rootUri, and rootPath
@@ -1239,7 +1237,7 @@ end
 ---
 --- 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})'``.
+--- via `vim.bo[bufnr].formatexpr = 'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})'`.
 ---
 ---@param opts table options for customizing the formatting expression which takes the
 ---                   following optional keys:
-- 
cgit 


From a5fe8f59d98398d04bed8586cee73864bbcdde92 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Tue, 27 Feb 2024 15:20:32 +0000
Subject: docs: improve/add documentation of Lua types

- Added `@inlinedoc` so single use Lua types can be inlined into the
  functions docs. E.g.

  ```lua
  --- @class myopts
  --- @inlinedoc
  ---
  --- Documentation for some field
  --- @field somefield integer

  --- @param opts myOpts
  function foo(opts)
  end
  ```

  Will be rendered as

  ```
  foo(opts)

    Parameters:
      - {opts} (table) Object with the fields:
               - somefield (integer) Documentation
                 for some field
  ```

- Marked many classes with with `@nodoc` or `(private)`.
  We can eventually introduce these when we want to.
---
 runtime/lua/vim/lsp.lua | 297 ++++++++----------------------------------------
 1 file changed, 48 insertions(+), 249 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 19497e40dc..8ebf4de3cb 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -108,12 +108,12 @@ function lsp._buf_get_line_ending(bufnr)
 end
 
 -- Tracks all clients created via lsp.start_client
-local active_clients = {} --- @type table<integer,lsp.Client>
+local active_clients = {} --- @type table<integer,vim.lsp.Client>
 local all_buffer_active_clients = {} --- @type table<integer,table<integer,true>>
-local uninitialized_clients = {} --- @type table<integer,lsp.Client>
+local uninitialized_clients = {} --- @type table<integer,vim.lsp.Client>
 
 ---@param bufnr? integer
----@param fn fun(client: lsp.Client, client_id: integer, bufnr: integer)
+---@param fn fun(client: vim.lsp.Client, client_id: integer, bufnr: integer)
 local function for_each_buffer_client(bufnr, fn, restrict_client_ids)
   validate({
     fn = { fn, 'f' },
@@ -200,105 +200,15 @@ local function once(fn)
   end
 end
 
--- FIXME: DOC: Shouldn't need to use a dummy function
---
---- LSP client object. You can get an active client object via
---- |vim.lsp.get_client_by_id()| or |vim.lsp.get_clients()|.
+--- @class vim.lsp.start.Opts
+--- @inlinedoc
 ---
---- - Methods:
----   - request(method, params, [handler], bufnr)
----      Sends a request to the server.
----      This is a thin wrapper around {client.rpc.request} with some additional
----      checking.
----      If {handler} is not specified,  If one is not found there, then an error will occur.
----      Returns: {status}, {[client_id]}. {status} is a boolean indicating if
----      the notification was successful. If it is `false`, then it will always
----      be `false` (the client has shutdown).
----      If {status} is `true`, the function returns {request_id} as the second
----      result. You can use this with `client.cancel_request(request_id)`
----      to cancel the request.
+--- 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.
+--- @field reuse_client fun(client: vim.lsp.Client, config: table): boolean
 ---
----   - request_sync(method, params, timeout_ms, bufnr)
----      Sends a request to the server and synchronously waits for the response.
----      This is a wrapper around {client.request}
----      Returns: { err=err, result=result }, a dictionary, where `err` and `result` come from
----      the |lsp-handler|. On timeout, cancel or error, returns `(nil, err)` where `err` is a
----      string describing the failure reason. If the request was unsuccessful returns `nil`.
----
----   - notify(method, params)
----      Sends a notification to an LSP server.
----      Returns: a boolean to indicate if the notification was successful. If
----      it is false, then it will always be false (the client has shutdown).
----
----   - cancel_request(id)
----      Cancels a request with a given request id.
----      Returns: same as `notify()`.
----
----   - stop([force])
----      Stops a client, optionally with force.
----      By default, it will just ask the server to shutdown without force.
----      If you request to stop a client which has previously been requested to
----      shutdown, it will automatically escalate and force shutdown.
----
----   - is_stopped()
----      Checks whether a client is stopped.
----      Returns: true if the client is fully stopped.
----
----   - on_attach(client, bufnr)
----      Runs the on_attach function from the client's config if it was defined.
----      Useful for buffer-local setup.
----
----   - supports_method(method, [opts]): 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.
----
---- - Members
----   - {id} (number): The id allocated to the client.
----
----   - {name} (string): If a name is specified on creation, that will be
----     used. Otherwise it is just the client id. This is used for
----     logs and messages.
----
----   - {rpc} (table): RPC client object, for low level interaction with the
----     client. See |vim.lsp.rpc.start()|.
----
----   - {offset_encoding} (string): The encoding used for communicating
----     with the server. You can modify this in the `config`'s `on_init` method
----     before text is sent to the server.
----
----   - {handlers} (table): The handlers used by the client as described in |lsp-handler|.
----
----   - {commands} (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.
----
----   - {requests} (table): The current pending requests in flight
----     to the server. Entries are key-value pairs with the key
----     being the request ID while the value is a table with `type`,
----     `bufnr`, and `method` key-value pairs. `type` is either "pending"
----     for an active request, or "cancel" for a cancel request. It will
----     be "complete" ephemerally while executing |LspRequest| autocmds
----     when replies are received from the server.
----
----   - {config} (table): Reference of the table that was passed by the user
----     to |vim.lsp.start_client()|.
----
----   - {server_capabilities} (table): Response from the server sent on
----     `initialize` describing the server's capabilities.
----
----   - {progress} A ring buffer (|vim.ringbuf()|) containing progress messages
----     sent by the server.
----
----   - {settings} Map with language server specific settings.
----     See {config} in |vim.lsp.start_client()|
----
----   - {flags} A table with flags for the client. See {config} in |vim.lsp.start_client()|
-lsp.client = nil
-
---- @class lsp.StartOpts
---- @field reuse_client fun(client: lsp.Client, config: table): boolean
+--- Buffer handle to attach to if starting or re-using a client (0 for current).
 --- @field bufnr integer
 
 --- Create a new LSP client and start a language server or reuses an already
@@ -337,17 +247,9 @@ lsp.client = nil
 --- Either use |:au|, |nvim_create_autocmd()| or put the call in a
 --- `ftplugin/<filetype_name>.lua` (See |ftplugin-name|)
 ---
----@param config lsp.ClientConfig Same configuration as documented in |vim.lsp.start_client()|
----@param opts lsp.StartOpts? Optional keyword arguments:
----             - reuse_client (fun(client: client, config: table): boolean)
----                            Predicate used to decide if a client should be re-used.
----                            Used on all running clients.
----                            The default implementation re-uses a client if name
----                            and root_dir matches.
----             - bufnr (number)
----                     Buffer handle to attach to if starting or re-using a
----                     client (0 for current).
----@return integer? client_id
+--- @param config vim.lsp.ClientConfig Configuration for the server.
+--- @param opts vim.lsp.start.Opts? Optional keyword arguments
+--- @return integer? client_id
 function lsp.start(config, opts)
   opts = opts or {}
   local reuse_client = opts.reuse_client
@@ -428,7 +330,7 @@ local function is_empty_or_default(bufnr, option)
 end
 
 ---@private
----@param client lsp.Client
+---@param client vim.lsp.Client
 ---@param bufnr integer
 function lsp._set_defaults(client, bufnr)
   if
@@ -482,7 +384,7 @@ local function reset_defaults(bufnr)
   end)
 end
 
---- @param client lsp.Client
+--- @param client vim.lsp.Client
 local function on_client_init(client)
   local id = client.id
   uninitialized_clients[id] = nil
@@ -552,121 +454,9 @@ local function on_client_exit(code, signal, client_id)
   end)
 end
 
--- FIXME: DOC: Currently all methods on the `vim.lsp.client` object are
--- documented twice: Here, and on the methods themselves (e.g.
--- `client.request()`). This is a workaround for the vimdoc generator script
--- not handling method names correctly. If you change the documentation on
--- either, please make sure to update the other as well.
---
 --- Starts and initializes a client with the given configuration.
----
---- Field `cmd` in {config} is required.
----
----@param config (lsp.ClientConfig) Configuration for the server:
---- - cmd: (string[]|fun(dispatchers: table):table) 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=|getcwd()|) 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: (table) List of workspace folders passed to the
----       language server. For backwards compatibility rootUri and rootPath will be
----       derived from the first workspace folder in this list. See `workspaceFolders` in
----       the LSP spec.
----
---- - capabilities: Map overriding the default capabilities defined by
----       \|vim.lsp.protocol.make_client_capabilities()|, passed to the language
----       server on initialization. Hint: use make_client_capabilities() and modify
----       its result.
----
----     - Note: To send an empty dictionary use |vim.empty_dict()|, else it will be encoded as an
----       array.
----
---- - handlers: Map of language server method names to |lsp-handler|
----
---- - settings: Map with language server specific settings. These are
----       returned to the language server if requested via `workspace/configuration`.
----       Keys are case-sensitive.
----
---- - commands: table Table that maps string of clientside commands to user-defined functions.
----       Commands passed to start_client take precedence over the global command registry. Each key
----       must be a unique command name, and the value is a function which is called if any LSP action
----       (code action, code lenses, ...) triggers the command.
----
---- - init_options Values to pass in the initialization request
----       as `initializationOptions`. See `initialize` in the LSP spec.
----
---- - name: (string, default=client-id) Name in log messages.
----
---- - get_language_id: function(bufnr, filetype) -> language ID as string.
----       Defaults to the filetype.
----
---- - offset_encoding: (default="utf-16") One of "utf-8", "utf-16",
----       or "utf-32" which is the encoding that the LSP server expects. Client does
----       not verify this is correct.
----
---- - on_error: Callback with parameters (code, ...), invoked
----       when the client operation throws an error. `code` is a number describing
----       the error. Other arguments may be passed depending on the error kind.  See
----       `vim.lsp.rpc.client_errors` for possible errors.
----       Use `vim.lsp.rpc.client_errors[code]` to get human-friendly name.
----
---- - before_init: Callback with parameters (initialize_params, config)
----       invoked before the LSP "initialize" phase, where `params` contains the
----       parameters being sent to the server and `config` is the config that was
----       passed to |vim.lsp.start_client()|. You can use this to modify parameters before
----       they are sent.
----
---- - on_init: Callback (client, initialize_result) invoked after LSP
----       "initialize", where `result` is a table of `capabilities` and anything else
----       the server may send. For example, clangd sends
----       `initialize_result.offsetEncoding` if `capabilities.offsetEncoding` was
----       sent to it. You can only modify the `client.offset_encoding` here before
----       any notifications are sent.
----
---- - on_exit Callback (code, signal, client_id) invoked on client
---- exit.
----   - code: exit code of the process
----   - signal: number describing the signal used to terminate (if any)
----   - client_id: client handle
----
---- - on_attach: Callback (client, bufnr) invoked when client
----       attaches to a buffer.
----
---- - trace: ("off" | "messages" | "verbose" | nil) passed directly to the language
----       server in the initialize request. Invalid/empty values will default to "off"
----
---- - flags: A table with flags for the client. The current (experimental) flags are:
----   - allow_incremental_sync (bool, default true): Allow using incremental sync for buffer edits
----   - debounce_text_changes (number, default 150): Debounce didChange
----         notifications to the server by the given number in milliseconds. No debounce
----         occurs if nil
----   - exit_timeout (number|boolean, default false): Milliseconds to wait for server to
----         exit cleanly after sending the "shutdown" request before sending kill -15.
----         If set to false, nvim exits immediately after sending the "shutdown" request to the server.
----
---- - root_dir: (string) Directory where the LSP
----       server will base its workspaceFolders, rootUri, and rootPath
----       on initialization.
----
----@return integer|nil client_id. |vim.lsp.get_client_by_id()| Note: client may not be
+--- @param config vim.lsp.ClientConfig Configuration for the server.
+--- @return integer|nil 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.
 function lsp.start_client(config)
@@ -927,7 +717,7 @@ end
 ---
 ---@param client_id integer client id
 ---
----@return (nil|lsp.Client) client rpc object
+---@return (nil|vim.lsp.Client) client rpc object
 function lsp.get_client_by_id(client_id)
   return active_clients[client_id] or uninitialized_clients[client_id]
 end
@@ -943,7 +733,7 @@ end
 
 --- Stops a client(s).
 ---
---- You can also use the `stop()` function on a |vim.lsp.client| object.
+--- You can also use the `stop()` function on a |vim.lsp.Client| object.
 --- To stop all clients:
 ---
 --- ```lua
@@ -953,7 +743,7 @@ end
 --- By default asks the server to shutdown, unless stop was requested
 --- already for this client, then force-shutdown is attempted.
 ---
----@param client_id integer|table id or |vim.lsp.client| object, or list thereof
+---@param client_id integer|vim.lsp.Client id or |vim.lsp.Client| object, or list thereof
 ---@param force boolean|nil shutdown forcefully
 function lsp.stop_client(client_id, force)
   local ids = type(client_id) == 'table' and client_id or { client_id }
@@ -968,28 +758,32 @@ function lsp.stop_client(client_id, force)
   end
 end
 
----@class vim.lsp.get_clients.filter
----@field id integer|nil Match clients by id
----@field bufnr integer|nil match clients attached to the given buffer
----@field name string|nil match clients by name
----@field method string|nil match client by supported method name
+--- Key-value pairs used to filter the returned clients.
+--- @class vim.lsp.get_clients.Filter
+--- @inlinedoc
+---
+--- Only return clients with the given id
+--- @field id? integer
+---
+--- Only return clients attached to this buffer
+--- @field bufnr? integer
+---
+--- Only return clients with the given name
+--- @field name? string
+---
+--- Only return clients supporting the given method
+--- @field method? string
 
 --- Get active clients.
 ---
----@param filter vim.lsp.get_clients.filter|nil (table|nil) A table with
----              key-value pairs used to filter the returned clients.
----              The available keys are:
----               - id (number): Only return clients with the given id
----               - bufnr (number): Only return clients attached to this buffer
----               - name (string): Only return clients with the given name
----               - method (string): Only return clients supporting the given method
----@return lsp.Client[]: List of |vim.lsp.client| objects
+---@param filter? vim.lsp.get_clients.Filter
+---@return vim.lsp.Client[]: List of |vim.lsp.Client| objects
 function lsp.get_clients(filter)
   validate({ filter = { filter, 't', true } })
 
   filter = filter or {}
 
-  local clients = {} --- @type lsp.Client[]
+  local clients = {} --- @type vim.lsp.Client[]
 
   local t = filter.bufnr and (all_buffer_active_clients[resolve_bufnr(filter.bufnr)] or {})
     or active_clients
@@ -1233,15 +1027,20 @@ function lsp.omnifunc(findstart, base)
   return vim.lsp._completion.omnifunc(findstart, base)
 end
 
+--- @class vim.lsp.formatexpr.Opts
+--- @inlinedoc
+---
+--- The timeout period for the formatting request.
+--- (default: 500ms).
+--- @field timeout_ms integer
+
 --- 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})'`.
 ---
----@param opts table options for customizing the formatting expression which takes the
----                   following optional keys:
----                   * timeout_ms (default 500ms). The timeout period for the formatting request.
+---@param opts? vim.lsp.formatexpr.Opts
 function lsp.formatexpr(opts)
   opts = opts or {}
   local timeout_ms = opts.timeout_ms or 500
@@ -1313,14 +1112,14 @@ function lsp.client_is_stopped(client_id)
 end
 
 --- Gets a map of client_id:client pairs for the given buffer, where each value
---- is a |vim.lsp.client| object.
+--- is a |vim.lsp.Client| object.
 ---
 ---@param bufnr (integer|nil): Buffer handle, or 0 for current
 ---@return table result is table of (client_id, client) pairs
 ---@deprecated Use |vim.lsp.get_clients()| instead.
 function lsp.buf_get_clients(bufnr)
   vim.deprecate('vim.lsp.buf_get_clients()', 'vim.lsp.get_clients()', '0.12')
-  local result = {} --- @type table<integer,lsp.Client>
+  local result = {} --- @type table<integer,vim.lsp.Client>
   for _, client in ipairs(lsp.get_clients({ bufnr = resolve_bufnr(bufnr) })) do
     result[client.id] = client
   end
-- 
cgit 


From a4290f462ed7dc81e17b09bd27877b106b24b6bd Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Tue, 5 Mar 2024 12:06:15 +0000
Subject: docs(lua): improvements for LSP and Diagnostic

---
 runtime/lua/vim/lsp.lua | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 8ebf4de3cb..ef5d9d7cff 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -961,16 +961,15 @@ end
 ---
 --- 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} (default 1000) ms.
+--- different. Waits a maximum of {timeout_ms}.
 ---
----@param bufnr (integer) Buffer handle, or 0 for current.
----@param method (string) LSP method name
----@param params (table|nil) Parameters to send to the server
----@param timeout_ms (integer|nil) Maximum time in milliseconds to wait for a
----                               result. Defaults to 1000
----
----@return table<integer, {err: lsp.ResponseError, result: any}>|nil (table) result Map of client_id:request_result.
----@return string|nil err On timeout, cancel, or error, `err` is a string describing the failure reason, and `result` is nil.
+---@param bufnr integer Buffer handle, or 0 for current.
+---@param method string LSP method name
+---@param params table? Parameters to send to the server
+---@param timeout_ms integer? Maximum time in milliseconds to wait for a result.
+---                           (default: `1000`)
+---@return table<integer, {err: lsp.ResponseError, result: any}>? result Map of client_id:request_result.
+---@return string? err On timeout, cancel, or error, `err` is a string describing the failure reason, and `result` is nil.
 function lsp.buf_request_sync(bufnr, method, params, timeout_ms)
   local request_results
 
-- 
cgit 


From e52c25b7617ac6401b080f76b0e227161dfef230 Mon Sep 17 00:00:00 2001
From: Maria José Solano <majosolano99@gmail.com>
Date: Sat, 2 Mar 2024 13:11:23 -0800
Subject: feat(lua): deprecate vim.tbl_add_reverse_lookup

---
 runtime/lua/vim/lsp.lua | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

(limited to 'runtime/lua/vim/lsp.lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index ef5d9d7cff..d5c376ba44 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -146,9 +146,10 @@ end
 local client_errors_base = table.maxn(lsp.rpc.client_errors)
 local client_errors_offset = 0
 
-local function new_error_index()
+local function client_error(name)
   client_errors_offset = client_errors_offset + 1
-  return client_errors_base + client_errors_offset
+  local index = client_errors_base + client_errors_offset
+  return { [name] = index, [index] = name }
 end
 
 --- Error codes to be used with `on_error` from |vim.lsp.start_client|.
@@ -158,12 +159,10 @@ end
 lsp.client_errors = tbl_extend(
   'error',
   lsp.rpc.client_errors,
-  vim.tbl_add_reverse_lookup({
-    BEFORE_INIT_CALLBACK_ERROR = new_error_index(),
-    ON_INIT_CALLBACK_ERROR = new_error_index(),
-    ON_ATTACH_ERROR = new_error_index(),
-    ON_EXIT_CALLBACK_ERROR = new_error_index(),
-  })
+  client_error('BEFORE_INIT_CALLBACK_ERROR'),
+  client_error('ON_INIT_CALLBACK_ERROR'),
+  client_error('ON_ATTACH_ERROR'),
+  client_error('ON_EXIT_CALLBACK_ERROR')
 )
 
 ---@private
-- 
cgit