Merge de17f182bb into 7121983c45

- Replace all uses of vim.regex with simpler Lua patterns.
- Replace all uses of vim.fn.substitute with string.gsub.
- Rework error handling so expected errors are passed back via a return.
  - These get routed up an passed to `vim.notify()`
  - Any other errors will cause a stack trace.
- Reworked the module initialization of `localfile_arg`
- Updated all type annotations.
- Refactored CLI completion by introduction a parse_cmdline()
  function.
- Simplified `show_toc()`
- Refactor highlighting
- Inline some functions
- Fix completion on MacOS 13 and earlier.
  - Prefer `manpath -q` over `man -w`
- Make completion more efficient by avoiding vim.fn.sort and vim.fn.uniq
  - Reimplement using a single loop

runtime/doc/lsp.txt

@@ -1126,6 +1126,9 @@ Lua module: vim.lsp.client                                        *lsp-client*
       • {server_capabilities}   (`lsp.ServerCapabilities?`) Response from the
                                 server sent on `initialize` describing the
                                 server's capabilities.
+      • {server_info}           (`lsp.ServerInfo?`) Response from the server
+                                sent on `initialize` describing information
+                                about the server.
       • {progress}              (`vim.lsp.Client.Progress`) A ring buffer
                                 (|vim.ringbuf()|) containing progress messages
                                 sent by the server. See

runtime/doc/news.txt

@@ -115,6 +115,7 @@ LSP
 • |vim.lsp.util.make_position_params()|, |vim.lsp.util.make_range_params()|
   and |vim.lsp.util.make_given_range_params()| now require the `position_encoding`
   parameter.
+• `:checkhealth vim.lsp` displays the server version (if available).
 
 LUA
 

runtime/lua/vim/lsp.lua

@@ -211,7 +211,7 @@ local function reuse_client_default(client, config)
 
   for _, config_folder in ipairs(config_folders) do
     local found = false
-    for _, client_folder in ipairs(client.workspace_folders) do
+    for _, client_folder in ipairs(client.workspace_folders or {}) do
       if config_folder.uri == client_folder.uri then
         found = true
         break

runtime/lua/vim/lsp/client.lua

@@ -174,6 +174,10 @@ local validate = vim.validate
 --- capabilities.
 --- @field server_capabilities lsp.ServerCapabilities?
 ---
+--- Response from the server sent on `initialize` describing information about
+--- the server.
+--- @field server_info lsp.ServerInfo?
+---
 --- A ring buffer (|vim.ringbuf()|) containing progress messages
 --- sent by the server.
 --- @field progress vim.lsp.Client.Progress
@@ -556,6 +560,8 @@ function Client:initialize()
       self.offset_encoding = self.server_capabilities.positionEncoding
     end
 
+    self.server_info = result.serverInfo
+
     if next(self.settings) then
       self:notify(ms.workspace_didChangeConfiguration, { settings = self.settings })
     end

runtime/lua/vim/lsp/health.lua

@@ -40,6 +40,8 @@ local function check_active_clients()
   local clients = vim.lsp.get_clients()
   if next(clients) then
     for _, client in pairs(clients) do
+      local server_version = vim.tbl_get(client, 'server_info', 'version')
+        or '? (no serverInfo.version response)'
       local cmd ---@type string
       local ccmd = client.config.cmd
       if type(ccmd) == 'table' then
@@ -62,6 +64,7 @@ local function check_active_clients()
       end
       report_info(table.concat({
         string.format('%s (id: %d)', client.name, client.id),
+        string.format('- Version: %s', server_version),
         dirs_info,
         string.format('- Command: %s', cmd),
         string.format('- Settings: %s', vim.inspect(client.settings, { newline = '\n  ' })),

runtime/lua/vim/lsp/rpc.lua

@@ -16,34 +16,21 @@ local function format_message_with_content_length(message)
   })
 end
 
----@class (private) vim.lsp.rpc.Headers: {string: any}
----@field content_length integer
-
---- Parses an LSP Message's header
+--- Extract content-length from the msg header
 ---
----@param header string The header to parse.
----@return vim.lsp.rpc.Headers#parsed headers
-local function parse_headers(header)
-  assert(type(header) == 'string', 'header must be a string')
-  --- @type vim.lsp.rpc.Headers
-  local headers = {}
-  for line in vim.gsplit(header, '\r\n', { plain = true }) do
+---@param header string The header to parse
+---@return integer?
+local function get_content_length(header)
+  for line in header:gmatch('(.-)\r\n') do
     if line == '' then
       break
     end
-    --- @type string?, string?
-    local key, value = line:match('^%s*(%S+)%s*:%s*(.+)%s*$')
-    if key then
-      key = key:lower():gsub('%-', '_') --- @type string
-      headers[key] = value
-    else
-      log.error('invalid header line %q', line)
-      error(string.format('invalid header line %q', line))
+    local key, value = line:match('^%s*(%S+)%s*:%s*(%d+)%s*$')
+    if key and key:lower() == 'content-length' then
+      return tonumber(value)
     end
   end
-  headers.content_length = tonumber(headers.content_length)
-    or error(string.format('Content-Length not found in headers. %q', header))
-  return headers
+  error('Content-Length not found in header: ' .. header)
 end
 
 -- This is the start of any possible header patterns. The gsub converts it to a
@@ -52,70 +39,102 @@ local header_start_pattern = ('content'):gsub('%w', function(c)
   return '[' .. c .. c:upper() .. ']'
 end)
 
+
+local has_strbuffer, strbuffer = pcall(require, "string.buffer")
+
 --- The actual workhorse.
-local function request_parser_loop()
-  local buffer = '' -- only for header part
-  while true do
-    -- A message can only be complete if it has a double CRLF and also the full
-    -- payload, so first let's check for the CRLFs
-    local start, finish = buffer:find('\r\n\r\n', 1, true)
-    -- Start parsing the headers
-    if start then
-      -- This is a workaround for servers sending initial garbage before
-      -- sending headers, such as if a bash script sends stdout. It assumes
-      -- that we know all of the headers ahead of time. At this moment, the
-      -- only valid headers start with "Content-*", so that's the thing we will
-      -- be searching for.
-      -- TODO(ashkan) I'd like to remove this, but it seems permanent :(
-      local buffer_start = buffer:find(header_start_pattern)
-      if not buffer_start then
-        error(
-          string.format(
-            "Headers were expected, a different response was received. The server response was '%s'.",
-            buffer
-          )
-        )
-      end
-      local headers = parse_headers(buffer:sub(buffer_start, start - 1))
-      local content_length = headers.content_length
-      -- Use table instead of just string to buffer the message. It prevents
-      -- a ton of strings allocating.
-      -- ref. http://www.lua.org/pil/11.6.html
-      ---@type string[]
-      local body_chunks = { buffer:sub(finish + 1) }
-      local body_length = #body_chunks[1]
-      -- Keep waiting for data until we have enough.
-      while body_length < content_length do
-        ---@type string
+---@type function
+local request_parser_loop
+
+if has_strbuffer then
+  request_parser_loop = function()
+    local buf = strbuffer.new()
+    while true do
+      local msg = buf:tostring()
+      local header_end = msg:find('\r\n\r\n', 1, true)
+      if header_end then
+        local header = buf:get(header_end + 1)
+        buf:skip(2) -- skip past header boundary
+        local content_length = get_content_length(header)
+        while #buf < content_length do
+          local chunk = coroutine.yield()
+          buf:put(chunk)
+        end
+        local body = buf:get(content_length)
+        local chunk = coroutine.yield(body)
+        buf:put(chunk)
+      else
         local chunk = coroutine.yield()
-          or error('Expected more data for the body. The server may have died.') -- TODO hmm.
-        table.insert(body_chunks, chunk)
-        body_length = body_length + #chunk
+        buf:put(chunk)
       end
-      local last_chunk = body_chunks[#body_chunks]
+    end
+  end
+else
+  request_parser_loop = function()
+    local buffer = '' -- only for header part
+    while true do
+      -- A message can only be complete if it has a double CRLF and also the full
+      -- payload, so first let's check for the CRLFs
+      local header_end, body_start = buffer:find('\r\n\r\n', 1, true)
+      -- Start parsing the headers
+      if header_end then
+        -- This is a workaround for servers sending initial garbage before
+        -- sending headers, such as if a bash script sends stdout. It assumes
+        -- that we know all of the headers ahead of time. At this moment, the
+        -- only valid headers start with "Content-*", so that's the thing we will
+        -- be searching for.
+        -- TODO(ashkan) I'd like to remove this, but it seems permanent :(
+        local buffer_start = buffer:find(header_start_pattern)
+        if not buffer_start then
+          error(
+            string.format(
+              "Headers were expected, a different response was received. The server response was '%s'.",
+              buffer
+            )
+          )
+        end
+        local header = buffer:sub(buffer_start, header_end + 1)
+        local content_length = get_content_length(header)
+        -- Use table instead of just string to buffer the message. It prevents
+        -- a ton of strings allocating.
+        -- ref. http://www.lua.org/pil/11.6.html
+        ---@type string[]
+        local body_chunks = { buffer:sub(body_start + 1) }
+        local body_length = #body_chunks[1]
+        -- Keep waiting for data until we have enough.
+        while body_length < content_length do
+          ---@type string
+          local chunk = coroutine.yield()
+            or error('Expected more data for the body. The server may have died.') -- TODO hmm.
+          table.insert(body_chunks, chunk)
+          body_length = body_length + #chunk
+        end
+        local last_chunk = body_chunks[#body_chunks]
 
-      body_chunks[#body_chunks] = last_chunk:sub(1, content_length - body_length - 1)
-      local rest = ''
-      if body_length > content_length then
-        rest = last_chunk:sub(content_length - body_length)
+        body_chunks[#body_chunks] = last_chunk:sub(1, content_length - body_length - 1)
+        local rest = ''
+        if body_length > content_length then
+          rest = last_chunk:sub(content_length - body_length)
+        end
+        local body = table.concat(body_chunks)
+        -- Yield our data.
+
+        --- @type string
+        local data = coroutine.yield(body)
+          or error('Expected more data for the body. The server may have died.')
+        buffer = rest .. data
+      else
+        -- Get more data since we don't have enough.
+        --- @type string
+        local data = coroutine.yield()
+          or error('Expected more data for the header. The server may have died.')
+        buffer = buffer .. data
       end
-      local body = table.concat(body_chunks)
-      -- Yield our data.
-
-      --- @type string
-      local data = coroutine.yield(headers, body)
-        or error('Expected more data for the body. The server may have died.')
-      buffer = rest .. data
-    else
-      -- Get more data since we don't have enough.
-      --- @type string
-      local data = coroutine.yield()
-        or error('Expected more data for the header. The server may have died.')
-      buffer = buffer .. data
     end
   end
 end
 
+
 local M = {}
 
 --- Mapping of error codes used by the client
@@ -237,7 +256,7 @@ local default_dispatchers = {
 --- @param on_exit? fun()
 --- @param on_error fun(err: any)
 function M.create_read_loop(handle_body, on_exit, on_error)
-  local parse_chunk = coroutine.wrap(request_parser_loop) --[[@as fun(chunk: string?): vim.lsp.rpc.Headers?, string?]]
+  local parse_chunk = coroutine.wrap(request_parser_loop) --[[@as fun(chunk: string?): string]]
   parse_chunk()
   return function(err, chunk)
     if err then
@@ -253,9 +272,9 @@ function M.create_read_loop(handle_body, on_exit, on_error)
     end
 
     while true do
-      local headers, body = parse_chunk(chunk)
-      if headers then
-        handle_body(assert(body))
+      local body = parse_chunk(chunk)
+      if body then
+        handle_body(body)
         chunk = ''
       else
         break

runtime/plugin/man.lua

@@ -8,9 +8,9 @@ vim.api.nvim_create_user_command('Man', function(params)
   if params.bang then
     man.init_pager()
   else
-    local ok, err = pcall(man.open_page, params.count, params.smods, params.fargs)
-    if not ok then
-      vim.notify(man.errormsg or err, vim.log.levels.ERROR)
+    local err = man.open_page(params.count, params.smods, params.fargs)
+    if err then
+      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
     end
   end
 end, {
@@ -31,6 +31,9 @@ vim.api.nvim_create_autocmd('BufReadCmd', {
   pattern = 'man://*',
   nested = true,
   callback = function(params)
-    require('man').read_page(vim.fn.matchstr(params.match, 'man://\\zs.*'))
+    local err = require('man').read_page(assert(params.match:match('man://(.*)')))
+    if err then
+      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
+    end
   end,
 })

src/nvim/api/vimscript.c

@@ -229,10 +229,9 @@ static Object _call_function(String fn, Array args, dict_T *self, Arena *arena,
   funcexe.fe_selfdict = self;
 
   TRY_WRAP(err, {
-    // call_func() retval is deceptive, ignore it.  Instead we set `msg_list`
-    // (see above) to capture abort-causing non-exception errors.
-    call_func(fn.data, (int)fn.size, &rettv, (int)args.size,
-              vim_args, &funcexe);
+    // call_func() retval is deceptive, ignore it.  Instead TRY_WRAP sets `msg_list` to capture
+    // abort-causing non-exception errors.
+    (void)call_func(fn.data, (int)fn.size, &rettv, (int)args.size, vim_args, &funcexe);
   });
 
   if (!ERROR_SET(err)) {
@@ -280,18 +279,23 @@ Object nvim_call_dict_function(Object dict, String fn, Array args, Arena *arena,
   typval_T rettv;
   bool mustfree = false;
   switch (dict.type) {
-  case kObjectTypeString:
+  case kObjectTypeString: {
+    int eval_ret;
     TRY_WRAP(err, {
-      eval0(dict.data.string.data, &rettv, NULL, &EVALARG_EVALUATE);
-      clear_evalarg(&EVALARG_EVALUATE, NULL);
-    });
+        eval_ret = eval0(dict.data.string.data, &rettv, NULL, &EVALARG_EVALUATE);
+        clear_evalarg(&EVALARG_EVALUATE, NULL);
+      });
     if (ERROR_SET(err)) {
       return rv;
     }
+    if (eval_ret != OK) {
+      abort();  // Should not happen.
+    }
     // Evaluation of the string arg created a new dict or increased the
     // refcount of a dict. Not necessary for a RPC dict.
     mustfree = true;
     break;
+  }
   case kObjectTypeDict:
     object_to_vim(dict, &rettv, err);
     break;

test/functional/plugin/lsp_spec.lua

@@ -1854,6 +1854,20 @@ describe('LSP', function()
         end,
       }
     end)
+
+    it('vim.lsp.start when existing client has no workspace_folders', function()
+      exec_lua(create_server_definition)
+      eq(
+        { 2, 'foo', 'foo' },
+        exec_lua(function()
+          local server = _G._create_server()
+          vim.lsp.start { cmd = server.cmd, name = 'foo' }
+          vim.lsp.start { cmd = server.cmd, name = 'foo', root_dir = 'bar' }
+          local foos = vim.lsp.get_clients()
+          return { #foos, foos[1].name, foos[2].name }
+        end)
+      )
+    end)
   end)
 
   describe('parsing tests', function()

test/functional/plugin/man_spec.lua

@@ -21,13 +21,12 @@ local function get_search_history(name)
     local man = require('man')
     local res = {}
     --- @diagnostic disable-next-line:duplicate-set-field
-    man.find_path = function(sect, name0)
+    man._find_path = function(name0, sect)
       table.insert(res, { sect, name0 })
       return nil
     end
-    local ok, rv = pcall(man.open_page, -1, { tab = 0 }, args)
-    assert(not ok)
-    assert(rv and rv:match('no manual entry'))
+    local err = man.open_page(-1, { tab = 0 }, args)
+    assert(err and err:match('no manual entry'))
     return res
   end)
 end
@@ -225,7 +224,7 @@ describe(':Man', function()
     matches('^/.+', actual_file)
     local args = { nvim_prog, '--headless', '+:Man ' .. actual_file, '+q' }
     matches(
-      ('Error detected while processing command line:\r\n' .. 'man.lua: "no manual entry for %s"'):format(
+      ('Error detected while processing command line:\r\n' .. 'man.lua: no manual entry for %s'):format(
         pesc(actual_file)
       ),
       fn.system(args, { '' })
@@ -235,8 +234,8 @@ describe(':Man', function()
 
   it('tries variants with spaces, underscores #22503', function()
     eq({
-      { '', 'NAME WITH SPACES' },
-      { '', 'NAME_WITH_SPACES' },
+      { vim.NIL, 'NAME WITH SPACES' },
+      { vim.NIL, 'NAME_WITH_SPACES' },
     }, get_search_history('NAME WITH SPACES'))
     eq({
       { '3', 'some other man' },
@@ -255,8 +254,8 @@ describe(':Man', function()
       { 'n', 'some_other_man' },
     }, get_search_history('n some other man'))
     eq({
-      { '', '123some other man' },
-      { '', '123some_other_man' },
+      { vim.NIL, '123some other man' },
+      { vim.NIL, '123some_other_man' },
     }, get_search_history('123some other man'))
     eq({
       { '1', 'other_man' },
@@ -265,11 +264,10 @@ describe(':Man', function()
   end)
 
   it('can complete', function()
-    t.skip(t.is_os('mac') and t.is_arch('x86_64'), 'not supported on intel mac')
     eq(
       true,
       exec_lua(function()
-        return #require('man').man_complete('f', 'Man g') > 0
+        return #require('man').man_complete('f', 'Man f') > 0
       end)
     )
   end)