Merge #36925 :lsp command

runtime/doc/index.txt

@@ -1420,6 +1420,7 @@ Tag		Command		Action ~
 |:lpfile|	:lpf[ile]	go to last location in previous file
 |:lrewind|	:lr[ewind]	go to the specified location, default first one
 |:ls|		:ls		list all buffers
+|:lsp|		:lsp		language server protocol
 |:ltag|		:lt[ag]		jump to tag and add matching tags to the
 				location list
 |:lunmap|	:lu[nmap]	like ":unmap!" but includes Lang-Arg mode

runtime/doc/lsp.txt

@@ -116,6 +116,29 @@ To remove or override BUFFER-LOCAL defaults, define a |LspAttach| handler: >lua
       end,
     })
 <
+==============================================================================
+COMMANDS                                                    *:lsp*
+
+:lsp enable {name}?                                       *:lsp-enable*
+    Enables the given lsp clients. If no names are given, all clients
+    configured with |vim.lsp.config()| with a filetype matching the current
+    buffer's filetype are enabled. Use |vim.lsp.enable()| for non-interactive
+    use.
+
+:lsp disable {name}?                                      *:lsp-disable*
+    Disables (and stops) the given lsp clients. If no names are given,
+    all clients attached to the current buffer are disabled. Use
+    |vim.lsp.enable()| with `enable=false` for non-interactive use.
+
+:lsp restart {client}?                                    *:lsp-restart*
+    Restarts the given lsp clients. If no client names are given, all active
+    clients attached to the current buffer are restarted.
+
+:lsp stop {client}?                                       *:lsp-stop*
+    Stops the given lsp clients. If no client names are given, all active
+    clients attached to the current buffer are stopped. Use |Client:stop()|
+    for non-interactive use.
+
 ==============================================================================
 CONFIG                                                  *lsp-config*
 
@@ -1023,12 +1046,6 @@ enable({name}, {enable})                                    *vim.lsp.enable()*
         vim.lsp.enable({'lua_ls', 'pyright'})
 <
 
-    Example: *lsp-restart* Passing `false` stops and detaches the client(s).
-    Thus you can "restart" LSP by disabling and re-enabling a given config: >lua
-        vim.lsp.enable('clangd', false)
-        vim.lsp.enable('clangd', true)
-<
-
     Example: To dynamically decide whether LSP is activated, define a
     |lsp-root_dir()| function which calls `on_dir()` only when you want that
     config to activate: >lua

runtime/doc/news.txt

@@ -291,6 +291,8 @@ LSP
 • Support for `workspace/diagnostic/refresh`:
   https://microsoft.github.io/language-server-protocol/specification/#diagnostic_refresh
 - Support for dynamic registration for `textDocument/diagnostic`
+• |:lsp| for interactively enabling, disabling, restarting, and stopping lsp
+  clients.
 
 LUA
 

runtime/doc/vim_diff.txt

@@ -307,6 +307,7 @@ Commands:
 - |:EditQuery|
 - |:Inspect|
 - |:InspectTree|
+- |:lsp|
 - |:Man| is available by default, with many improvements such as completion
 - |:match| can be invoked before highlight group is defined
 - |:restart|

runtime/lua/vim/_core/ex_cmd/lsp.lua

@@ -0,0 +1,212 @@
+local api = vim.api
+local lsp = vim.lsp
+
+local M = {}
+
+--- @return string[]
+local function get_client_names()
+  local client_names = vim
+    .iter(lsp.get_clients())
+    :map(function(client)
+      return client.name
+    end)
+    :totable()
+  return vim.list.unique(client_names)
+end
+
+--- @return string[]
+local function get_config_names()
+  local config_names = vim
+    .iter(api.nvim_get_runtime_file('lsp/*.lua', true))
+    --- @param path string
+    :map(function(path)
+      local file_name = path:match('[^/]*.lua$')
+      return file_name:sub(0, #file_name - 4)
+    end)
+    :totable()
+
+  --- @diagnostic disable-next-line
+  vim.list_extend(config_names, vim.tbl_keys(lsp.config._configs))
+
+  return vim
+    .iter(vim.list.unique(config_names))
+    --- @param name string
+    :filter(function(name)
+      return name ~= '*'
+    end)
+    :totable()
+end
+
+--- @param filter fun(string):boolean
+--- @return fun():string[]
+local function filtered_config_names(filter)
+  return function()
+    return vim.iter(get_config_names()):filter(filter):totable()
+  end
+end
+
+local complete_args = {
+  enable = filtered_config_names(function(name)
+    return not lsp.is_enabled(name)
+  end),
+  disable = filtered_config_names(function(name)
+    return lsp.is_enabled(name)
+  end),
+  restart = get_client_names,
+  stop = get_client_names,
+}
+
+--- @param names string[]
+--- @param enable? boolean
+local function checked_enable(names, enable)
+  for _, name in ipairs(names) do
+    if name:find('*') == nil and lsp.config[name] ~= nil then
+      lsp.enable(name, enable)
+    else
+      vim.notify(("No client config named '%s'"):format(name), vim.log.levels.ERROR)
+    end
+  end
+end
+
+--- @param config_names string[]
+local function ex_lsp_enable(config_names)
+  -- Default to enabling all clients matching the filetype of the current buffer.
+  if #config_names == 0 then
+    local filetype = vim.bo.filetype
+    for _, name in ipairs(get_config_names()) do
+      local filetypes = lsp.config[name].filetypes
+      if filetypes and vim.tbl_contains(filetypes, filetype) then
+        table.insert(config_names, name)
+      end
+    end
+  end
+
+  checked_enable(config_names)
+end
+
+--- @param config_names string[]
+local function ex_lsp_disable(config_names)
+  -- Default to disabling all clients attached to the current buffer.
+  if #config_names == 0 then
+    config_names = vim
+      .iter(lsp.get_clients { bufnr = api.nvim_get_current_buf() })
+      :map(function(client)
+        return client.name
+      end)
+      :filter(function(name)
+        return lsp.config[name] ~= nil
+      end)
+      :totable()
+  end
+
+  checked_enable(config_names, false)
+end
+
+--- @param client_names string[]
+--- @return vim.lsp.Client[]
+local function get_clients_from_names(client_names)
+  -- Default to stopping all active clients attached to the current buffer.
+  if #client_names == 0 then
+    return lsp.get_clients { bufnr = api.nvim_get_current_buf() }
+  else
+    return vim
+      .iter(client_names)
+      :map(function(name)
+        local clients = lsp.get_clients { name = name }
+        if #clients == 0 then
+          vim.notify(("No active clients named '%s'"):format(name), vim.log.levels.ERROR)
+        end
+        return clients
+      end)
+      :flatten()
+      :totable()
+  end
+end
+
+--- @param client_names string[]
+local function ex_lsp_restart(client_names)
+  local clients = get_clients_from_names(client_names)
+
+  for _, client in ipairs(clients) do
+    --- @type integer[]
+    local attached_buffers = vim.tbl_keys(client.attached_buffers)
+
+    -- Reattach new client once the old one exits
+    api.nvim_create_autocmd('LspDetach', {
+      group = api.nvim_create_augroup('nvim.lsp.ex_restart_' .. client.id, {}),
+      callback = function(info)
+        if info.data.client_id ~= client.id then
+          return
+        end
+
+        local new_client_id = lsp.start(client.config, { attach = false })
+        if new_client_id then
+          for _, buffer in ipairs(attached_buffers) do
+            lsp.buf_attach_client(buffer, new_client_id)
+          end
+        end
+
+        return true -- Delete autocmd
+      end,
+    })
+
+    client:stop(client.exit_timeout)
+  end
+end
+
+--- @param client_names string[]
+local function ex_lsp_stop(client_names)
+  local clients = get_clients_from_names(client_names)
+
+  for _, client in ipairs(clients) do
+    client:stop(client.exit_timeout)
+  end
+end
+
+local actions = {
+  enable = ex_lsp_enable,
+  disable = ex_lsp_disable,
+  restart = ex_lsp_restart,
+  stop = ex_lsp_stop,
+}
+
+local available_subcmds = vim.tbl_keys(actions)
+
+--- Implements command: `:lsp {subcmd} {name}?`.
+--- @param args string
+M.ex_lsp = function(args)
+  local fargs = api.nvim_parse_cmd('lsp ' .. args, {}).args
+  if not fargs then
+    return
+  end
+  local subcmd = fargs[1]
+  if not vim.list_contains(available_subcmds, subcmd) then
+    vim.notify(("Invalid subcommand '%s'"):format(subcmd), vim.log.levels.ERROR)
+    return
+  end
+
+  local clients = { unpack(fargs, 2) }
+
+  actions[subcmd](clients)
+end
+
+--- Completion logic for `:lsp` command
+--- @param line string content of the current command line
+--- @return string[] list of completions
+function M.lsp_complete(line)
+  local split = vim.split(line, '%s+')
+  if #split == 2 then
+    return available_subcmds
+  else
+    local subcmd = split[2]
+    return vim
+      .iter(complete_args[subcmd]())
+      --- @param n string
+      :map(function(n)
+        return vim.fn.escape(n, ' \t')
+      end)
+      :totable()
+  end
+end
+
+return M

runtime/lua/vim/lsp.lua

@@ -528,14 +528,6 @@ end
 --- vim.lsp.enable({'lua_ls', 'pyright'})
 --- ```
 ---
---- Example: [lsp-restart]() Passing `false` stops and detaches the client(s). Thus you can
---- "restart" LSP by disabling and re-enabling a given config:
----
---- ```lua
---- vim.lsp.enable('clangd', false)
---- vim.lsp.enable('clangd', true)
---- ```
----
 --- Example: To _dynamically_ decide whether LSP is activated, define a |lsp-root_dir()| function
 --- which calls `on_dir()` only when you want that config to activate:
 ---

src/nvim/cmdexpand.c

@@ -1301,6 +1301,7 @@ char *addstar(char *fname, size_t len, int context)
         || ((context == EXPAND_TAGS_LISTFILES || context == EXPAND_TAGS)
             && fname[0] == '/')
         || context == EXPAND_CHECKHEALTH
+        || context == EXPAND_LSP
         || context == EXPAND_LUA) {
       retval = xstrnsave(fname, len);
     } else {
@@ -2311,6 +2312,10 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, expa
     xp->xp_context = EXPAND_CHECKHEALTH;
     break;
 
+  case CMD_lsp:
+    xp->xp_context = EXPAND_LSP;
+    break;
+
   case CMD_retab:
     xp->xp_context = EXPAND_RETAB;
     xp->xp_pattern = (char *)arg;
@@ -2849,6 +2854,43 @@ static char *get_healthcheck_names(expand_T *xp FUNC_ATTR_UNUSED, int idx)
   return NULL;
 }
 
+/// Completion for |:lsp| command.
+///
+/// Given to ExpandGeneric() to obtain `:lsp` completion.
+/// @param[in] idx  Index of the item.
+/// @param[in] xp  Not used.
+static char *get_lsp_arg(expand_T *xp FUNC_ATTR_UNUSED, int idx)
+{
+  static Object names = OBJECT_INIT;
+  static char *last_xp_line = NULL;
+  static unsigned last_gen = 0;
+
+  if (last_xp_line == NULL || strcmp(last_xp_line,
+                                     xp->xp_line) != 0
+      || last_gen != get_cmdline_last_prompt_id()) {
+    xfree(last_xp_line);
+    last_xp_line = xstrdup(xp->xp_line);
+    MAXSIZE_TEMP_ARRAY(args, 1);
+    Error err = ERROR_INIT;
+
+    ADD_C(args, CSTR_AS_OBJ(xp->xp_line));
+    // Build the current command line as a Lua string argument
+    Object res = NLUA_EXEC_STATIC("return require'vim._core.ex_cmd.lsp'.lsp_complete(...)", args,
+                                  kRetObject, NULL,
+                                  &err);
+    api_clear_error(&err);
+    api_free_object(names);
+    names = res;
+    last_gen = get_cmdline_last_prompt_id();
+  }
+
+  if (names.type == kObjectTypeArray && idx < (int)names.data.array.size
+      && names.data.array.items[idx].type == kObjectTypeString) {
+    return names.data.array.items[idx].data.string.data;
+  }
+  return NULL;
+}
+
 /// Do the expansion based on xp->xp_context and "rmp".
 static int ExpandOther(char *pat, expand_T *xp, regmatch_T *rmp, char ***matches, int *numMatches)
 {
@@ -2891,6 +2933,7 @@ static int ExpandOther(char *pat, expand_T *xp, regmatch_T *rmp, char ***matches
     { EXPAND_SCRIPTNAMES, get_scriptnames_arg, true, false },
     { EXPAND_RETAB, get_retab_arg, true, true },
     { EXPAND_CHECKHEALTH, get_healthcheck_names, true, false },
+    { EXPAND_LSP, get_lsp_arg, true, false },
   };
   int ret = FAIL;
 

src/nvim/cmdexpand_defs.h

@@ -117,6 +117,7 @@ enum {
   EXPAND_RETAB,
   EXPAND_CHECKHEALTH,
   EXPAND_LUA,
+  EXPAND_LSP,
 };
 
 /// Type used by ExpandGeneric()

src/nvim/ex_cmds.lua

@@ -1670,6 +1670,12 @@ M.cmds = {
     addr_type = 'ADDR_NONE',
     func = 'buflist_list',
   },
+  {
+    command = 'lsp',
+    flags = bit.bor(NEEDARG, EXTRA),
+    addr_type = 'ADDR_NONE',
+    func = 'ex_lsp',
+  },
   {
     command = 'move',
     flags = bit.bor(RANGE, WHOLEFOLD, EXTRA, TRLBAR, CMDWIN, LOCK_OK, MODIFY),

src/nvim/ex_docmd.c

@@ -8048,6 +8048,21 @@ static void ex_terminal(exarg_T *eap)
   do_cmdline_cmd(ex_cmd);
 }
 
+/// ":lsp {subcmd} {clients}"
+static void ex_lsp(exarg_T *eap)
+{
+  Error err = ERROR_INIT;
+  MAXSIZE_TEMP_ARRAY(args, 1);
+
+  ADD_C(args, CSTR_AS_OBJ(eap->arg));
+
+  NLUA_EXEC_STATIC("require'vim._core.ex_cmd.lsp'.ex_lsp(...)", args, kRetNilBool, NULL, &err);
+  if (ERROR_SET(&err)) {
+    emsg(err.msg);
+  }
+  api_clear_error(&err);
+}
+
 /// ":fclose"
 static void ex_fclose(exarg_T *eap)
 {

test/functional/ex_cmds/lsp_spec.lua

@@ -0,0 +1,129 @@
+local t = require('test.testutil')
+local n = require('test.functional.testnvim')()
+local t_lsp = require('test.functional.plugin.lsp.testutil')
+
+local clear = n.clear
+local eq = t.eq
+local exec_lua = n.exec_lua
+
+local create_server_definition = t_lsp.create_server_definition
+
+describe(':lsp', function()
+  before_each(function()
+    clear()
+    exec_lua(create_server_definition)
+    exec_lua(function()
+      local server = _G._create_server()
+      vim.lsp.config('dummy', {
+        filetypes = { 'lua' },
+        cmd = server.cmd,
+      })
+      vim.cmd('set ft=lua')
+    end)
+  end)
+
+  for _, test_with_arguments in ipairs({ true, false }) do
+    local test_message_suffix, lsp_command_suffix
+    if test_with_arguments then
+      test_message_suffix = ' with arguments'
+      lsp_command_suffix = ' dummy'
+    else
+      test_message_suffix = ' without arguments'
+      lsp_command_suffix = ''
+    end
+
+    it('enable' .. test_message_suffix, function()
+      local is_enabled = exec_lua(function()
+        vim.cmd('lsp enable' .. lsp_command_suffix)
+        return vim.lsp.is_enabled('dummy')
+      end)
+      eq(true, is_enabled)
+    end)
+
+    it('disable' .. test_message_suffix, function()
+      local is_enabled = exec_lua(function()
+        vim.lsp.enable('dummy')
+        vim.cmd('lsp disable' .. lsp_command_suffix)
+        return vim.lsp.is_enabled('dummy')
+      end)
+      eq(false, is_enabled)
+    end)
+
+    it('restart' .. test_message_suffix, function()
+      local ids_differ = exec_lua(function()
+        vim.lsp.enable('dummy')
+        local old_id = vim.lsp.get_clients()[1].id
+
+        vim.cmd('lsp restart' .. lsp_command_suffix)
+        vim.wait(1000, function()
+          return old_id ~= vim.lsp.get_clients()[1].id
+        end)
+        local new_id = vim.lsp.get_clients()[1].id
+        return old_id ~= new_id
+      end)
+      eq(true, ids_differ)
+    end)
+
+    it('stop' .. test_message_suffix, function()
+      local running_clients = exec_lua(function()
+        vim.lsp.enable('dummy')
+        vim.cmd('lsp stop' .. lsp_command_suffix)
+        vim.wait(1000, function()
+          return #vim.lsp.get_clients() == 0
+        end)
+        return #vim.lsp.get_clients()
+      end)
+      eq(0, running_clients)
+    end)
+  end
+
+  it('subcommand completion', function()
+    local completions = exec_lua(function()
+      return vim.fn.getcompletion('lsp ', 'cmdline')
+    end)
+    eq({ 'disable', 'enable', 'restart', 'stop' }, completions)
+  end)
+
+  it('argument completion', function()
+    local completions = exec_lua(function()
+      return vim.fn.getcompletion('lsp enable ', 'cmdline')
+    end)
+    eq({ 'dummy' }, completions)
+  end)
+
+  it('argument completion with spaces', function()
+    local cmd_length = exec_lua(function()
+      local server = _G._create_server()
+      vim.lsp.config('client name with space', {
+        cmd = server.cmd,
+      })
+      local completion = vim.fn.getcompletion('lsp enable cl ', 'cmdline')[1]
+      return #vim.api.nvim_parse_cmd('lsp enable ' .. completion, {}).args
+    end)
+    eq(2, cmd_length)
+  end)
+
+  it('argument completion with special characters', function()
+    local cmd_length = exec_lua(function()
+      local server = _G._create_server()
+      vim.lsp.config('client"name|with\tsymbols', {
+        cmd = server.cmd,
+      })
+      local completion = vim.fn.getcompletion('lsp enable cl ', 'cmdline')[1]
+      return #vim.api.nvim_parse_cmd('lsp enable ' .. completion, {}).args
+    end)
+    eq(2, cmd_length)
+  end)
+
+  it('fail with no runtime without crashing', function()
+    clear {
+      args_rm = { '-u' },
+      args = { '-u', 'NONE' },
+      env = { VIMRUNTIME = 'non-existent' },
+    }
+    eq(
+      [[Vim(lsp):Lua: [string "<nvim>"]:0: module 'vim._core.ex_cmd.lsp' not found:]],
+      vim.split(t.pcall_err(n.command, 'lsp enable dummy'), '\n')[1]
+    )
+  end)
+end)

test/old/testdir/test_cmdline.vim

@@ -1289,7 +1289,7 @@ func Test_cmdline_complete_various()
 
   " completion for a command with a trailing command
   call feedkeys(":ls | ls\<C-A>\<C-B>\"\<CR>", 'xt')
-  call assert_equal("\"ls | ls", @:)
+  call assert_equal("\"ls | ls lsp", @:)
 
   " completion for a command with an CTRL-V escaped argument
   call feedkeys(":ls \<C-V>\<C-V>a\<C-A>\<C-B>\"\<CR>", 'xt')