Merge deae451b26 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/api.txt

@@ -3199,8 +3199,8 @@ nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                       like a tooltip near the buffer text).
                   • row: Row position in units of "screen cell height", may be
                     fractional.
-                  • col: Column position in units of "screen cell width", may
-                    be fractional.
+                  • col: Column position in units of screen cell width, may be
+                    fractional.
                   • focusable: Enable focus by user actions (wincmds, mouse
                     events). Defaults to true. Non-focusable windows can be
                     entered by |nvim_set_current_win()|, or, when the `mouse`
@@ -3290,6 +3290,9 @@ nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                   • hide: If true the floating window will be hidden.
                   • vertical: Split vertically |:vertical|.
                   • split: Split direction: "left", "right", "above", "below".
+                  • _cmdline_offset: (EXPERIMENTAL) When provided, anchor the
+                    |cmdline-completion| popupmenu to this window, with an
+                    offset in screen cell width.
 
     Return: ~
         Window handle, or 0 on error

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/man.lua

@@ -1,19 +1,8 @@
 local api, fn = vim.api, vim.fn
 
-local FIND_ARG = '-w'
-local localfile_arg = true -- Always use -l if possible. #6683
-
----@type table[]
-local buf_hls = {}
-
 local M = {}
 
-local function man_error(msg)
-  M.errormsg = 'man.lua: ' .. vim.inspect(msg)
-  error(M.errormsg)
-end
-
--- Run a system command and timeout after 30 seconds.
+--- Run a system command and timeout after 10 seconds.
 --- @param cmd string[]
 --- @param silent boolean?
 --- @param env? table<string,string|number>
@@ -24,7 +13,7 @@ local function system(cmd, silent, env)
   if not silent then
     if r.code ~= 0 then
       local cmd_str = table.concat(cmd, ' ')
-      man_error(string.format("command error '%s': %s", cmd_str, r.stderr))
+      error(string.format("command error '%s': %s", cmd_str, r.stderr))
     end
     assert(r.stdout ~= '')
   end
@@ -32,65 +21,64 @@ local function system(cmd, silent, env)
   return assert(r.stdout)
 end
 
+--- @enum Man.Attribute
+local Attrs = {
+  None = 0,
+  Bold = 1,
+  Underline = 2,
+  Italic = 3,
+}
+
 --- @param line string
----@param linenr integer
-local function highlight_line(line, linenr)
+--- @param row integer
+--- @param hls {attr:Man.Attribute,row:integer,start:integer,final:integer}[]
+--- @return string
+local function render_line(line, row, hls)
   --- @type string[]
   local chars = {}
   local prev_char = ''
   local overstrike, escape, osc8 = false, false, false
 
-  ---@type table<integer,{attr:integer,start:integer,final:integer}>
-  local hls = {} -- Store highlight groups as { attr, start, final }
-
-  local NONE, BOLD, UNDERLINE, ITALIC = 0, 1, 2, 3
-  local hl_groups = { [BOLD] = 'manBold', [UNDERLINE] = 'manUnderline', [ITALIC] = 'manItalic' }
-  local attr = NONE
+  local attr = Attrs.None
   local byte = 0 -- byte offset
 
-  local function end_attr_hl(attr_)
-    for i, hl in ipairs(hls) do
-      if hl.attr == attr_ and hl.final == -1 then
-        hl.final = byte
-        hls[i] = hl
-      end
-    end
-  end
+  local hls_start = #hls + 1
 
+  --- @param code integer
   local function add_attr_hl(code)
     local continue_hl = true
     if code == 0 then
-      attr = NONE
+      attr = Attrs.None
       continue_hl = false
     elseif code == 1 then
-      attr = BOLD
+      attr = Attrs.Bold
     elseif code == 22 then
-      attr = BOLD
+      attr = Attrs.Bold
       continue_hl = false
     elseif code == 3 then
-      attr = ITALIC
+      attr = Attrs.Italic
     elseif code == 23 then
-      attr = ITALIC
+      attr = Attrs.Italic
       continue_hl = false
     elseif code == 4 then
-      attr = UNDERLINE
+      attr = Attrs.Underline
     elseif code == 24 then
-      attr = UNDERLINE
+      attr = Attrs.Underline
       continue_hl = false
     else
-      attr = NONE
+      attr = Attrs.None
       return
     end
 
     if continue_hl then
-      hls[#hls + 1] = { attr = attr, start = byte, final = -1 }
+      hls[#hls + 1] = { attr = attr, row = row, start = byte, final = -1 }
     else
-      if attr == NONE then
-        for a, _ in pairs(hl_groups) do
-          end_attr_hl(a)
+      for _, a in pairs(attr == Attrs.None and Attrs or { attr }) do
+        for i = hls_start, #hls do
+          if hls[i].attr == a and hls[i].final == -1 then
+            hls[i].final = byte
+          end
         end
-      else
-        end_attr_hl(attr)
       end
     end
   end
@@ -103,11 +91,11 @@ local function highlight_line(line, linenr)
     if overstrike then
       local last_hl = hls[#hls]
       if char == prev_char then
-        if char == '_' and attr == ITALIC and last_hl and last_hl.final == byte then
+        if char == '_' and attr == Attrs.Italic and last_hl and last_hl.final == byte then
           -- This underscore is in the middle of an italic word
-          attr = ITALIC
+          attr = Attrs.Italic
         else
-          attr = BOLD
+          attr = Attrs.Bold
         end
       elseif prev_char == '_' then
         -- Even though underline is strictly what this should be. <bs>_ was used by nroff to
@@ -116,26 +104,26 @@ local function highlight_line(line, linenr)
         -- See:
         -- - https://unix.stackexchange.com/questions/274658/purpose-of-ascii-text-with-overstriking-file-format/274795#274795
         -- - https://cmd.inp.nsk.su/old/cmd2/manuals/unix/UNIX_Unleashed/ch08.htm
-        -- attr = UNDERLINE
-        attr = ITALIC
+        -- attr = Attrs.Underline
+        attr = Attrs.Italic
       elseif prev_char == '+' and char == 'o' then
         -- bullet (overstrike text '+^Ho')
-        attr = BOLD
+        attr = Attrs.Bold
         char = '·'
       elseif prev_char == '·' and char == 'o' then
         -- bullet (additional handling for '+^H+^Ho^Ho')
-        attr = BOLD
+        attr = Attrs.Bold
         char = '·'
       else
         -- use plain char
-        attr = NONE
+        attr = Attrs.None
       end
 
       -- Grow the previous highlight group if possible
       if last_hl and last_hl.attr == attr and last_hl.final == byte then
         last_hl.final = byte + #char
       else
-        hls[#hls + 1] = { attr = attr, start = byte, final = byte + #char }
+        hls[#hls + 1] = { attr = attr, row = row, start = byte, final = byte + #char }
       end
 
       overstrike = false
@@ -158,10 +146,11 @@ local function highlight_line(line, linenr)
       local sgr = prev_char:match('^%[([\032-\063]*)m$')
       -- Ignore escape sequences with : characters, as specified by ITU's T.416
       -- Open Document Architecture and interchange format.
-      if sgr and not string.find(sgr, ':') then
+      if sgr and not sgr:find(':') then
         local match --- @type string?
         while sgr and #sgr > 0 do
           -- Match against SGR parameters, which may be separated by ';'
+          --- @type string?, string?
           match, sgr = sgr:match('^(%d*);?(.*)')
           add_attr_hl(match + 0) -- coerce to number
         end
@@ -187,55 +176,40 @@ local function highlight_line(line, linenr)
     end
   end
 
-  for _, hl in ipairs(hls) do
-    if hl.attr ~= NONE then
-      buf_hls[#buf_hls + 1] = {
-        0,
-        -1,
-        hl_groups[hl.attr],
-        linenr - 1,
-        hl.start,
-        hl.final,
-      }
-    end
-  end
-
   return table.concat(chars, '')
 end
 
+local HlGroups = {
+  [Attrs.Bold] = 'manBold',
+  [Attrs.Underline] = 'manUnderline',
+  [Attrs.Italic] = 'manItalic',
+}
+
 local function highlight_man_page()
   local mod = vim.bo.modifiable
   vim.bo.modifiable = true
 
   local lines = api.nvim_buf_get_lines(0, 0, -1, false)
+
+  --- @type {attr:Man.Attribute,row:integer,start:integer,final:integer}[]
+  local hls = {}
+
   for i, line in ipairs(lines) do
-    lines[i] = highlight_line(line, i)
+    lines[i] = render_line(line, i - 1, hls)
   end
+
   api.nvim_buf_set_lines(0, 0, -1, false, lines)
 
-  for _, args in ipairs(buf_hls) do
-    api.nvim_buf_add_highlight(unpack(args))
+  for _, hl in ipairs(hls) do
+    api.nvim_buf_add_highlight(0, -1, HlGroups[hl.attr], hl.row, hl.start, hl.final)
   end
-  buf_hls = {}
 
   vim.bo.modifiable = mod
 end
 
--- replace spaces in a man page name with underscores
--- intended for PostgreSQL, which has man pages like 'CREATE_TABLE(7)';
--- while editing SQL source code, it's nice to visually select 'CREATE TABLE'
--- and hit 'K', which requires this transformation
----@param str string
----@return string
-local function spaces_to_underscores(str)
-  local res = str:gsub('%s', '_')
-  return res
-end
-
----@param sect string|nil
----@param name string|nil
----@param silent boolean
-local function get_path(sect, name, silent)
+--- @param name? string
+--- @param sect? string
+local function get_path(name, sect)
   name = name or ''
   sect = sect or ''
   -- Some man implementations (OpenBSD) return all available paths from the
@@ -258,12 +232,12 @@ local function get_path(sect, name, silent)
   -- inconsistently supported. Instead, call -w with a section and a name.
   local cmd --- @type string[]
   if sect == '' then
-    cmd = { 'man', FIND_ARG, name }
+    cmd = { 'man', '-w', name }
   else
-    cmd = { 'man', FIND_ARG, sect, name }
+    cmd = { 'man', '-w', sect, name }
   end
 
-  local lines = system(cmd, silent)
+  local lines = system(cmd, true)
   local results = vim.split(lines, '\n', { trimempty = true })
 
   if #results == 0 then
@@ -282,7 +256,7 @@ local function get_path(sect, name, silent)
   --- @param v string
   local namematches = vim.tbl_filter(function(v)
     local tail = fn.fnamemodify(v, ':t')
-    return string.find(tail, name, 1, true)
+    return tail:find(name, 1, true) ~= nil
   end, results) or {}
   local sectmatches = {}
 
@@ -293,73 +267,59 @@ local function get_path(sect, name, silent)
     end, namematches)
   end
 
-  return fn.substitute(sectmatches[1] or namematches[1] or results[1], [[\n\+$]], '', '')
+  return (sectmatches[1] or namematches[1] or results[1]):gsub('\n+$', '')
 end
 
----@param text string
----@param pat_or_re string
-local function matchstr(text, pat_or_re)
-  local re = type(pat_or_re) == 'string' and vim.regex(pat_or_re) or pat_or_re
-
-  ---@type integer, integer
-  local s, e = re:match_str(text)
-
-  if s == nil then
-    return
-  end
-
-  return text:sub(vim.str_utfindex(text, 'utf-32', s) + 1, vim.str_utfindex(text, 'utf-32', e))
-end
-
--- attempt to extract the name and sect out of 'name(sect)'
--- otherwise just return the largest string of valid characters in ref
+--- Attempt to extract the name and sect out of 'name(sect)'
+--- otherwise just return the largest string of valid characters in ref
 --- @param ref string
----@return string, string
-local function extract_sect_and_name_ref(ref)
-  ref = ref or ''
-  if ref:sub(1, 1) == '-' then -- try ':Man -pandoc' with this disabled.
-    man_error("manpage name cannot start with '-'")
+--- @return string? name
+--- @return string? sect
+--- @return string? err
+local function parse_ref(ref)
+  if ref == '' or ref:sub(1, 1) == '-' then
+    return nil, nil, ('invalid manpage reference "%s"'):format(ref)
   end
-  local ref1 = ref:match('[^()]+%([^()]+%)')
-  if not ref1 then
-    local name = ref:match('[^()]+')
-    if not name then
-      man_error('manpage reference cannot contain only parentheses: ' .. ref)
-    end
-    return '', name
-  end
-  local parts = vim.split(ref1, '(', { plain = true })
+
+  -- match "<name>(<sect>)"
+  -- note: name can contain spaces
+  local name, sect = ref:match('([^()]+)%(([^()]+)%)')
+  if name then
     -- see ':Man 3X curses' on why tolower.
     -- TODO(nhooyr) Not sure if this is portable across OSs
     -- but I have not seen a single uppercase section.
-  local sect = vim.split(parts[2] or '', ')', { plain = true })[1]:lower()
-  local name = parts[1]
-  return sect, name
+    return name, sect:lower()
   end
 
--- find_path attempts to find the path to a manpage
--- based on the passed section and name.
---
--- 1. If manpage could not be found with the given sect and name,
---    then try all the sections in b:man_default_sects.
--- 2. If it still could not be found, then we try again without a section.
--- 3. If still not found but $MANSECT is set, then we try again with $MANSECT
---    unset.
--- 4. If a path still wasn't found, return nil.
+  name = ref:match('[^()]+')
+  if not name then
+    return nil, nil, ('invalid manpage reference "%s"'):format(ref)
+  end
+  return name
+end
+
+--- Attempts to find the path to a manpage based on the passed section and name.
+---
+--- 1. If manpage could not be found with the given sect and name,
+---    then try all the sections in b:man_default_sects.
+--- 2. If it still could not be found, then we try again without a section.
+--- 3. If still not found but $MANSECT is set, then we try again with $MANSECT
+---    unset.
+--- 4. If a path still wasn't found, return nil.
+--- @param name string?
 --- @param sect string?
----@param name string
-function M.find_path(sect, name)
+--- @return string? path
+function M._find_path(name, sect)
   if sect and sect ~= '' then
-    local ret = get_path(sect, name, true)
+    local ret = get_path(name, sect)
     if ret then
       return ret
     end
   end
 
   if vim.b.man_default_sects ~= nil then
-    local sects = vim.split(vim.b.man_default_sects, ',', { plain = true, trimempty = true })
-    for _, sec in ipairs(sects) do
-      local ret = get_path(sec, name, true)
+    for sec in vim.gsplit(vim.b.man_default_sects, ',', { trimempty = true }) do
+      local ret = get_path(name, sec)
       if ret then
         return ret
       end
@@ -367,17 +327,18 @@ function M.find_path(sect, name)
   end
 
   -- if none of the above worked, we will try with no section
-  local res_empty_sect = get_path('', name, true)
-  if res_empty_sect then
-    return res_empty_sect
+  local ret = get_path(name)
+  if ret then
+    return ret
   end
 
   -- if that still didn't work, we will check for $MANSECT and try again with it
   -- unset
   if vim.env.MANSECT then
+    --- @type string
     local mansect = vim.env.MANSECT
     vim.env.MANSECT = nil
-    local res = get_path('', name, true)
+    local res = get_path(name)
     vim.env.MANSECT = mansect
     if res then
       return res
@@ -388,21 +349,24 @@ function M.find_path(sect, name)
   return nil
 end
 
-local EXT_RE = vim.regex([[\.\%([glx]z\|bz2\|lzma\|Z\)$]])
-
--- Extracts the name/section from the 'path/name.sect', because sometimes the actual section is
--- more specific than what we provided to `man` (try `:Man 3 App::CLI`).
--- Also on linux, name seems to be case-insensitive. So for `:Man PRIntf`, we
--- still want the name of the buffer to be 'printf'.
+--- Extracts the name/section from the 'path/name.sect', because sometimes the
+--- actual section is more specific than what we provided to `man`
+--- (try `:Man 3 App::CLI`). Also on linux, name seems to be case-insensitive.
+--- So for `:Man PRIntf`, we still want the name of the buffer to be 'printf'.
 --- @param path string
----@return string, string
-local function extract_sect_and_name_path(path)
+--- @return string name
+--- @return string sect
+local function parse_path(path)
   local tail = fn.fnamemodify(path, ':t')
-  if EXT_RE:match_str(path) then -- valid extensions
+  if
+    path:match('%.[glx]z$')
+    or path:match('%.bz2$')
+    or path:match('%.lzma$')
+    or path:match('%.Z$')
+  then
     tail = fn.fnamemodify(tail, ':r')
   end
-  local name, sect = tail:match('^(.+)%.([^.]+)$')
-  return sect, name
+  return tail:match('^(.+)%.([^.]+)$')
 end
 
 --- @return boolean
@@ -433,6 +397,10 @@ local function set_options()
   vim.bo.filetype = 'man'
 end
 
+--- Always use -l if possible. #6683
+--- @type boolean?
+local localfile_arg
+
 --- @param path string
 --- @param silent boolean?
 --- @return string
@@ -444,11 +412,17 @@ local function get_page(path, silent)
   if (vim.g.man_hardwrap or 1) ~= 1 then
     manwidth = 999
   elseif vim.env.MANWIDTH then
-    manwidth = vim.env.MANWIDTH
+    manwidth = vim.env.MANWIDTH --- @type string|integer
   else
     manwidth = api.nvim_win_get_width(0) - vim.o.wrapmargin
   end
 
+  if localfile_arg == nil then
+    local mpath = get_path('man')
+    -- Check for -l support.
+    localfile_arg = (mpath and system({ 'man', '-l', mpath }, true) or '') ~= ''
+  end
+
   local cmd = localfile_arg and { 'man', '-l', path } or { 'man', path }
 
   -- Force MANPAGER=cat to ensure Vim is not recursively invoked (by man-db).
@@ -461,47 +435,17 @@ local function get_page(path, silent)
   })
 end
 
----@param lnum integer
----@return string
-local function getline(lnum)
-  ---@diagnostic disable-next-line
-  return fn.getline(lnum)
-end
-
----@param page string
-local function put_page(page)
-  vim.bo.modifiable = true
-  vim.bo.readonly = false
-  vim.bo.swapfile = false
-
-  api.nvim_buf_set_lines(0, 0, -1, false, vim.split(page, '\n'))
-
-  while getline(1):match('^%s*$') do
-    api.nvim_buf_set_lines(0, 0, 1, false, {})
-  end
-  -- XXX: nroff justifies text by filling it with whitespace.  That interacts
-  -- badly with our use of $MANWIDTH=999.  Hack around this by using a fixed
-  -- size for those whitespace regions.
-  -- Use try/catch to avoid setting v:errmsg.
-  vim.cmd([[
-    try
-      keeppatterns keepjumps %s/\s\{199,}/\=repeat(' ', 10)/g
-    catch
-    endtry
-  ]])
-  vim.cmd('1') -- Move cursor to first line
-  highlight_man_page()
-  set_options()
-end
-
+--- @param path string
+--- @param psect string
 local function format_candidate(path, psect)
-  if matchstr(path, [[\.\%(pdf\|in\)$]]) then -- invalid extensions
+  if vim.endswith(path, '.pdf') or vim.endswith(path, '.in') then
+    -- invalid extensions
     return ''
   end
-  local sect, name = extract_sect_and_name_path(path)
+  local name, sect = parse_path(path)
   if sect == psect then
     return name
-  elseif sect and name and matchstr(sect, psect .. '.\\+$') then -- invalid extensions
+  elseif sect:match(psect .. '.+$') then -- invalid extensions
     -- We include the section if the user provided section is a prefix
     -- of the actual section.
     return ('%s(%s)'):format(name, sect)
@@ -509,63 +453,54 @@ local function format_candidate(path, psect)
   return ''
 end
 
----@generic T
----@param list T[]
----@param elem T
----@return T[]
-local function move_elem_to_head(list, elem)
-  ---@diagnostic disable-next-line:no-unknown
-  local list1 = vim.tbl_filter(function(v)
-    return v ~= elem
-  end, list)
-  return { elem, unpack(list1) }
-end
-
----@param sect string
 --- @param name string
----@return string[]
-local function get_paths(sect, name)
+--- @param sect? string
+--- @return string[] paths
+--- @return string? err
+local function get_paths(name, sect)
   -- Try several sources for getting the list man directories:
-  --   1. `man -w` (works on most systems)
-  --   2. `manpath`
+  --   1. `manpath -q`
+  --   2. `man -w` (works on most systems)
   --   3. $MANPATH
-  local mandirs_raw = vim.F.npcall(system, { 'man', FIND_ARG })
-    or vim.F.npcall(system, { 'manpath', '-q' })
+  --
+  -- Note we prefer `manpath -q` because `man -w`:
+  -- - does not work on MacOS 14 and later.
+  -- - only returns '/usr/bin/man' on MacOS 13 and earlier.
+  --- @type string?
+  local mandirs_raw = vim.F.npcall(system, { 'manpath', '-q' })
+    or vim.F.npcall(system, { 'man', '-w' })
     or vim.env.MANPATH
 
   if not mandirs_raw then
-    man_error("Could not determine man directories from: 'man -w', 'manpath' or $MANPATH")
+    return {}, "Could not determine man directories from: 'man -w', 'manpath' or $MANPATH"
   end
 
   local mandirs = table.concat(vim.split(mandirs_raw, '[:\n]', { trimempty = true }), ',')
+
+  sect = sect or ''
+
   --- @type string[]
   local paths = fn.globpath(mandirs, 'man[^\\/]*/' .. name .. '*.' .. sect .. '*', false, true)
 
   -- Prioritize the result from find_path as it obeys b:man_default_sects.
-  local first = M.find_path(sect, name)
+  local first = M._find_path(name, sect)
   if first then
-    paths = move_elem_to_head(paths, first)
+    --- @param v string
+    paths = vim.tbl_filter(function(v)
+      return v ~= first
+    end, paths)
+    table.insert(paths, 1, first)
   end
 
   return paths
 end
 
----@param sect string
----@param psect string
----@param name string
----@return string[]
-local function complete(sect, psect, name)
-  local pages = get_paths(sect, name)
-  -- We remove duplicates in case the same manpage in different languages was found.
-  return fn.uniq(fn.sort(vim.tbl_map(function(v)
-    return format_candidate(v, psect)
-  end, pages) or {}, 'i'))
-end
-
--- see extract_sect_and_name_ref on why tolower(sect)
 --- @param arg_lead string
 --- @param cmd_line string
-function M.man_complete(arg_lead, cmd_line, _)
+--- @return string? sect
+--- @return string? psect
+--- @return string? name
+local function parse_cmdline(arg_lead, cmd_line)
   local args = vim.split(cmd_line, '%s+', { trimempty = true })
   local cmd_offset = fn.index(args, 'Man')
   if cmd_offset > 0 then
@@ -575,13 +510,13 @@ function M.man_complete(arg_lead, cmd_line, _)
   end
 
   if #args > 3 then
-    return {}
+    return
   end
 
   if #args == 1 then
     -- returning full completion is laggy. Require some arg_lead to complete
-    -- return complete('', '', '')
-    return {}
+    -- return '', '', ''
+    return
   end
 
   if arg_lead:match('^[^()]+%([^()]*$') then
@@ -590,14 +525,15 @@ function M.man_complete(arg_lead, cmd_line, _)
     -- It will offer 'priclass.d(1m)' even though section is specified as 1.
     local tmp = vim.split(arg_lead, '(', { plain = true })
     local name = tmp[1]
+    -- See extract_sect_and_name_ref on why :lower()
     local sect = (tmp[2] or ''):lower()
-    return complete(sect, '', name)
+    return sect, '', name
   end
 
   if not args[2]:match('^[^()]+$') then
     -- cursor (|) is at ':Man 3() |' or ':Man (3|' or ':Man 3() pri|'
     -- or ':Man 3() pri |'
-    return {}
+    return
   end
 
   if #args == 2 then
@@ -617,52 +553,77 @@ function M.man_complete(arg_lead, cmd_line, _)
       name = arg_lead
       sect = ''
     end
-    return complete(sect, sect, name)
+    return sect, sect, name
   end
 
   if not arg_lead:match('[^()]+$') then
     -- cursor (|) is at ':Man 3 printf |' or ':Man 3 (pr)i|'
-    return {}
+    return
   end
 
   -- cursor (|) is at ':Man 3 pri|'
-  local name = arg_lead
-  local sect = args[2]:lower()
-  return complete(sect, sect, name)
+  local name, sect = arg_lead, args[2]:lower()
+  return sect, sect, name
+end
+
+--- @param arg_lead string
+--- @param cmd_line string
+function M.man_complete(arg_lead, cmd_line)
+  local sect, psect, name = parse_cmdline(arg_lead, cmd_line)
+  if not (sect and psect and name) then
+    return {}
+  end
+
+  local pages = get_paths(name, sect)
+
+  -- We check for duplicates in case the same manpage in different languages
+  -- was found.
+  local pages_fmt = {} --- @type string[]
+  local pages_fmt_keys = {} --- @type table<string,true>
+  for _, v in ipairs(pages) do
+    local x = format_candidate(v, psect)
+    local xl = x:lower() -- ignore case when searching avoiding duplicates
+    if not pages_fmt_keys[xl] then
+      pages_fmt[#pages_fmt + 1] = x
+      pages_fmt_keys[xl] = true
+    end
+  end
+  table.sort(pages_fmt)
+
+  return pages_fmt
 end
 
 --- @param pattern string
 --- @return {name:string,filename:string,cmd:string}[]
 function M.goto_tag(pattern, _, _)
-  local sect, name = extract_sect_and_name_ref(pattern)
+  local name, sect, err = parse_ref(pattern)
+  if err then
+    error(err)
+  end
 
-  local paths = get_paths(sect, name)
-  ---@type {name:string,title:string}[]
-  local structured = {}
+  local paths, err2 = get_paths(assert(name), sect)
+  if err2 then
+    error(err2)
+  end
+
+  --- @type table[]
+  local ret = {}
 
   for _, path in ipairs(paths) do
-    sect, name = extract_sect_and_name_path(path)
-    if sect and name then
-      structured[#structured + 1] = {
-        name = name,
-        title = name .. '(' .. sect .. ')',
-      }
-    end
-  end
-
-  ---@param entry {name:string,title:string}
-  return vim.tbl_map(function(entry)
-    return {
-      name = entry.name,
-      filename = 'man://' .. entry.title,
+    local pname, psect = parse_path(path)
+    ret[#ret + 1] = {
+      name = pname,
+      filename = ('man://%s(%s)'):format(pname, psect),
       cmd = '1',
     }
-  end, structured)
   end
 
--- Called when Nvim is invoked as $MANPAGER.
+  return ret
+end
+
+--- Called when Nvim is invoked as $MANPAGER.
 function M.init_pager()
-  if getline(1):match('^%s*$') then
+  if fn.getline(1):match('^%s*$') then
     api.nvim_buf_set_lines(0, 0, 1, false, {})
   else
     vim.cmd('keepjumps 1')
@@ -670,9 +631,10 @@ function M.init_pager()
   highlight_man_page()
   -- Guess the ref from the heading (which is usually uppercase, so we cannot
   -- know the correct casing, cf. `man glDrawArraysInstanced`).
-  local ref = fn.substitute(matchstr(getline(1), [[^[^)]\+)]]) or '', ' ', '_', 'g')
-  local ok, res = pcall(extract_sect_and_name_ref, ref)
-  vim.b.man_sect = ok and res or ''
+  --- @type string
+  local ref = (fn.getline(1):match('^[^)]+%)') or ''):gsub(' ', '_')
+  local _, sect, err = pcall(parse_ref, ref)
+  vim.b.man_sect = err ~= nil and sect or ''
 
   if not fn.bufname('%'):match('man://') then -- Avoid duplicate buffers, E95.
     vim.cmd.file({ 'man://' .. fn.fnameescape(ref):lower(), mods = { silent = true } })
@@ -681,21 +643,14 @@ function M.init_pager()
   set_options()
 end
 
----@param count integer
+--- Combine the name and sect into a manpage reference so that all
+--- verification/extraction can be kept in a single function.
 --- @param args string[]
-function M.open_page(count, smods, args)
-  local ref ---@type string
-  if #args == 0 then
-    ref = vim.bo.filetype == 'man' and fn.expand('<cWORD>') or fn.expand('<cword>')
-    if ref == '' then
-      man_error('no identifier under cursor')
-    end
-  elseif #args == 1 then
-    ref = args[1]
-  else
-    -- Combine the name and sect into a manpage reference so that all
-    -- verification/extraction can be kept in a single function.
-    if args[1]:match('^%d$') or args[1]:match('^%d%a') or args[1]:match('^%a$') then
+--- @return string? ref
+local function ref_from_args(args)
+  if #args <= 1 then
+    return args[1]
+  elseif args[1]:match('^%d$') or args[1]:match('^%d%a') or args[1]:match('^%a$') then
     -- NB: Valid sections are not only digits, but also:
     --  - <digit><word> (see POSIX mans),
     --  - and even <letter> and <word> (see, for example, by tcl/tk)
@@ -704,27 +659,48 @@ function M.open_page(count, smods, args)
     local sect = args[1]
     table.remove(args, 1)
     local name = table.concat(args, ' ')
-      ref = ('%s(%s)'):format(name, sect)
-    else
-      ref = table.concat(args, ' ')
+    return ('%s(%s)'):format(name, sect)
+  end
+
+  return table.concat(args, ' ')
+end
+
+--- @param count integer
+--- @param args string[]
+--- @return string? err
+function M.open_page(count, smods, args)
+  local ref = ref_from_args(args)
+  if not ref then
+    ref = vim.bo.filetype == 'man' and fn.expand('<cWORD>') or fn.expand('<cword>')
+    if ref == '' then
+      return 'no identifier under cursor'
     end
   end
 
-  local sect, name = extract_sect_and_name_ref(ref)
+  local name, sect, err = parse_ref(ref)
+  if err then
+    return err
+  end
+  assert(name)
+
   if count >= 0 then
     sect = tostring(count)
   end
 
   -- Try both spaces and underscores, use the first that exists.
-  local path = M.find_path(sect, name)
-  if path == nil then
-    path = M.find_path(sect, spaces_to_underscores(name))
-    if path == nil then
-      man_error('no manual entry for ' .. name)
+  local path = M._find_path(name, sect)
+  if not path then
+    --- Replace spaces in a man page name with underscores
+    --- intended for PostgreSQL, which has man pages like 'CREATE_TABLE(7)';
+    --- while editing SQL source code, it's nice to visually select 'CREATE TABLE'
+    --- and hit 'K', which requires this transformation
+    path = M._find_path(name:gsub('%s', '_'), sect)
+    if not path then
+      return 'no manual entry for ' .. name
     end
   end
 
-  sect, name = extract_sect_and_name_path(path)
+  name, sect = parse_path(path)
   local buf = api.nvim_get_current_buf()
   local save_tfu = vim.bo[buf].tagfunc
   vim.bo[buf].tagfunc = "v:lua.require'man'.goto_tag"
@@ -747,24 +723,51 @@ function M.open_page(count, smods, args)
 
   if not ok then
     error(ret)
-  else
+  end
   set_options()
-  end
 
   vim.b.man_sect = sect
 end
 
--- Called when a man:// buffer is opened.
+--- Called when a man:// buffer is opened.
+--- @return string? err
 function M.read_page(ref)
-  local sect, name = extract_sect_and_name_ref(ref)
-  local path = M.find_path(sect, name)
-  if path == nil then
-    man_error('no manual entry for ' .. name)
+  local name, sect, err = parse_ref(ref)
+  if err then
+    return err
   end
-  sect = extract_sect_and_name_path(path)
+
+  local path = M._find_path(name, sect)
+  if not path then
+    return 'no manual entry for ' .. name
+  end
+
+  local _, sect1 = parse_path(path)
   local page = get_page(path)
-  vim.b.man_sect = sect
-  put_page(page)
+
+  vim.b.man_sect = sect1
+  vim.bo.modifiable = true
+  vim.bo.readonly = false
+  vim.bo.swapfile = false
+
+  api.nvim_buf_set_lines(0, 0, -1, false, vim.split(page, '\n'))
+
+  while fn.getline(1):match('^%s*$') do
+    api.nvim_buf_set_lines(0, 0, 1, false, {})
+  end
+  -- XXX: nroff justifies text by filling it with whitespace.  That interacts
+  -- badly with our use of $MANWIDTH=999.  Hack around this by using a fixed
+  -- size for those whitespace regions.
+  -- Use try/catch to avoid setting v:errmsg.
+  vim.cmd([[
+    try
+      keeppatterns keepjumps %s/\s\{199,}/\=repeat(' ', 10)/g
+    catch
+    endtry
+  ]])
+  vim.cmd('1') -- Move cursor to first line
+  highlight_man_page()
+  set_options()
 end
 
 function M.show_toc()
@@ -781,24 +784,13 @@ function M.show_toc()
 
   local lnum = 2
   local last_line = fn.line('$') - 1
-  local section_title_re = vim.regex([[^\%( \{3\}\)\=\S.*$]])
-  local flag_title_re = vim.regex([[^\s\+\%(+\|-\)\S\+]])
   while lnum and lnum < last_line do
-    local text = getline(lnum)
-    if section_title_re:match_str(text) then
-      -- if text is a section title
+    local text = fn.getline(lnum)
+    if text:match('^%s+[-+]%S') or text:match('^   %S') or text:match('^%S') then
       toc[#toc + 1] = {
         bufnr = bufnr,
         lnum = lnum,
-        text = text,
-      }
-    elseif flag_title_re:match_str(text) then
-      -- if text is a flag title. we strip whitespaces and prepend two
-      -- spaces to have a consistent format in the loclist.
-      toc[#toc + 1] = {
-        bufnr = bufnr,
-        lnum = lnum,
-        text = '  ' .. fn.substitute(text, [[^\s*\(.\{-}\)\s*$]], [[\1]], ''),
+        text = text:gsub('^%s+', ''):gsub('%s+$', ''),
       }
     end
     lnum = fn.nextnonblank(lnum + 1)
@@ -810,19 +802,4 @@ function M.show_toc()
   vim.w.qf_toc = bufname
 end
 
-local function init()
-  local path = get_path('', 'man', true)
-  local page ---@type string?
-  if path ~= nil then
-    -- Check for -l support.
-    page = get_page(path, true)
-  end
-
-  if page == '' or page == nil then
-    localfile_arg = false
-  end
-end
-
-init()
-
 return M

runtime/lua/vim/_meta/api.lua

@@ -1769,8 +1769,7 @@ function vim.api.nvim_open_term(buffer, opts) end
 ---     - `row=0` and `col=0` if `anchor` is "SW" or "SE"
 ---       (thus like a tooltip near the buffer text).
 --- - row: Row position in units of "screen cell height", may be fractional.
---- - col: Column position in units of "screen cell width", may be
----          fractional.
+--- - col: Column position in units of screen cell width, may be fractional.
 --- - focusable: Enable focus by user actions (wincmds, mouse events).
 ---     Defaults to true. Non-focusable windows can be entered by
 ---     `nvim_set_current_win()`, or, when the `mouse` field is set to true,
@@ -1856,6 +1855,8 @@ function vim.api.nvim_open_term(buffer, opts) end
 --- - hide: If true the floating window will be hidden.
 --- - vertical: Split vertically `:vertical`.
 --- - split: Split direction: "left", "right", "above", "below".
+--- - _cmdline_offset: (EXPERIMENTAL) When provided, anchor the `cmdline-completion`
+---   popupmenu to this window, with an offset in screen cell width.
 --- @return integer # Window handle, or 0 on error
 function vim.api.nvim_open_win(buffer, enter, config) end
 

runtime/lua/vim/_meta/api_keysets.lua

@@ -307,6 +307,7 @@ error('Cannot require a meta file')
 --- @field noautocmd? boolean
 --- @field fixed? boolean
 --- @field hide? boolean
+--- @field _cmdline_offset? integer
 
 --- @class vim.api.keyset.win_text_height
 --- @field start_row? integer

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/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/keysets_defs.h

@@ -131,6 +131,7 @@ typedef struct {
   Boolean noautocmd;
   Boolean fixed;
   Boolean hide;
+  Integer _cmdline_offset;
 } Dict(win_config);
 
 typedef struct {

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);
+        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;

src/nvim/api/win_config.c

@@ -125,8 +125,7 @@
 ///       - `row=0` and `col=0` if `anchor` is "SW" or "SE"
 ///         (thus like a tooltip near the buffer text).
 ///   - row: Row position in units of "screen cell height", may be fractional.
-///   - col: Column position in units of "screen cell width", may be
-///            fractional.
+///   - col: Column position in units of screen cell width, may be fractional.
 ///   - focusable: Enable focus by user actions (wincmds, mouse events).
 ///       Defaults to true. Non-focusable windows can be entered by
 ///       |nvim_set_current_win()|, or, when the `mouse` field is set to true,
@@ -212,6 +211,8 @@
 ///   - hide: If true the floating window will be hidden.
 ///   - vertical: Split vertically |:vertical|.
 ///   - split: Split direction: "left", "right", "above", "below".
+///   - _cmdline_offset: (EXPERIMENTAL) When provided, anchor the |cmdline-completion|
+///     popupmenu to this window, with an offset in screen cell width.
 ///
 /// @param[out] err Error details, if any
 ///
@@ -295,6 +296,10 @@ Window nvim_open_win(Buffer buffer, Boolean enter, Dict(win_config) *config, Err
     goto cleanup;
   }
 
+  if (fconfig._cmdline_offset < INT_MAX) {
+    cmdline_win = wp;
+  }
+
   // Autocommands may close `wp` or move it to another tabpage, so update and check `tp` after each
   // event. In each case, `wp` should already be valid in `tp`, so switch_win should not fail.
   // Also, autocommands may free the `buf` to switch to, so store a bufref to check.
@@ -643,6 +648,11 @@ restore_curwin:
       didset_window_options(win, true);
     }
   }
+  if (fconfig._cmdline_offset < INT_MAX) {
+    cmdline_win = win;
+  } else if (win == cmdline_win && fconfig._cmdline_offset == INT_MAX) {
+    cmdline_win = NULL;
+  }
 #undef HAS_KEY_X
 }
 
@@ -773,6 +783,9 @@ Dict(win_config) nvim_win_get_config(Window window, Arena *arena, Error *err)
   const char *rel = (wp->w_floating && !config->external
                      ? float_relative_str[config->relative] : "");
   PUT_KEY_X(rv, relative, cstr_as_string(rel));
+  if (config->_cmdline_offset < INT_MAX) {
+    PUT_KEY_X(rv, _cmdline_offset, config->_cmdline_offset);
+  }
 
   return rv;
 }
@@ -1320,6 +1333,10 @@ static bool parse_win_config(win_T *wp, Dict(win_config) *config, WinConfig *fco
     fconfig->hide = config->hide;
   }
 
+  if (HAS_KEY_X(config, _cmdline_offset)) {
+    fconfig->_cmdline_offset = (int)config->_cmdline_offset;
+  }
+
   return true;
 
 fail:

src/nvim/buffer_defs.h

@@ -956,6 +956,7 @@ typedef struct {
   bool noautocmd;
   bool fixed;
   bool hide;
+  int _cmdline_offset;
 } WinConfig;
 
 #define WIN_CONFIG_INIT ((WinConfig){ .height = 0, .width = 0, \
@@ -969,7 +970,8 @@ typedef struct {
                                       .style = kWinStyleUnused, \
                                       .noautocmd = false, \
                                       .hide = false, \
-                                      .fixed = false })
+                                      .fixed = false, \
+                                      ._cmdline_offset = INT_MAX })
 
 // Structure to store last cursor position and topline.  Used by check_lnums()
 // and reset_lnums().

src/nvim/cmdexpand.c

@@ -365,7 +365,7 @@ static int cmdline_pum_create(CmdlineInfo *ccline, expand_T *xp, char **matches,
 
   // Compute the popup menu starting column
   char *endpos = showtail ? showmatches_gettail(xp->xp_pattern, true) : xp->xp_pattern;
-  if (ui_has(kUICmdline)) {
+  if (ui_has(kUICmdline) && cmdline_win == NULL) {
     compl_startcol = (int)(endpos - ccline->cmdbuff);
   } else {
     compl_startcol = cmd_screencol((int)(endpos - ccline->cmdbuff));
@@ -1067,13 +1067,10 @@ int showmatches(expand_T *xp, bool wildmenu)
     showtail = cmd_showtail;
   }
 
-  bool compl_use_pum = (ui_has(kUICmdline)
-                        ? ui_has(kUIPopupmenu)
-                        : wildmenu && (wop_flags & kOptWopFlagPum))
-                       || ui_has(kUIWildmenu);
-
-  if (compl_use_pum) {
-    // cmdline completion popup menu (with wildoptions=pum)
+  // Cmdline completion popup menu with ext_wildmenu, or wildoptions=pum and
+  // no ext_cmdline, or ext_popupmenu, or cmdline_win set (_cmdline_offset).
+  if (ui_has(kUIWildmenu) || ((!ui_has(kUICmdline) || ui_has(kUIPopupmenu) || cmdline_win != NULL)
+                              && wildmenu && (wop_flags & kOptWopFlagPum))) {
     return cmdline_pum_create(ccline, xp, matches, numMatches, showtail);
   }
 

src/nvim/ex_getln.c

@@ -2944,10 +2944,9 @@ static int cmd_startcol(void)
 int cmd_screencol(int bytepos)
 {
   int m;  // maximum column
-
   int col = cmd_startcol();
   if (KeyTyped) {
-    m = Columns * Rows;
+    m = cmdline_win ? cmdline_win->w_width_inner * cmdline_win->w_height_inner : Columns * Rows;
     if (m < 0) {        // overflow, Columns or Rows at weird value
       m = MAXCOL;
     }

src/nvim/globals.h

@@ -744,6 +744,7 @@ EXTERN int cmdwin_level INIT( = 0);   ///< cmdline recursion level
 EXTERN buf_T *cmdwin_buf INIT( = NULL);  ///< buffer of cmdline window or NULL
 EXTERN win_T *cmdwin_win INIT( = NULL);  ///< window of cmdline window or NULL
 EXTERN win_T *cmdwin_old_curwin INIT( = NULL);  ///< curwin before opening cmdline window or NULL
+EXTERN win_T *cmdline_win INIT( = NULL);  ///< window in use by ext_cmdline
 
 EXTERN char no_lines_msg[] INIT( = N_("--No lines in buffer--"));
 

src/nvim/popupmenu.c

@@ -154,11 +154,12 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
     validate_cursor_col(curwin);
     int above_row = 0;
     int below_row = cmdline_row;
-
+    win_T *target_win = (State == MODE_CMDLINE) ? cmdline_win : curwin;
     // wildoptions=pum
     if (State == MODE_CMDLINE) {
-      pum_win_row = ui_has(kUICmdline) ? 0 : cmdline_row;
-      cursor_col = cmd_startcol;
+      pum_win_row = cmdline_win ? cmdline_win->w_wrow : ui_has(kUICmdline) ? 0 : cmdline_row;
+      cursor_col = (cmdline_win ? cmdline_win->w_config._cmdline_offset : 0) + cmd_startcol;
+      cursor_col %= cmdline_win ? cmdline_win->w_width_inner : Columns;
       pum_anchor_grid = ui_has(kUICmdline) ? -1 : DEFAULT_GRID_HANDLE;
     } else {
       // anchor position: the start of the completed word
@@ -168,14 +169,16 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
       } else {
         cursor_col = curwin->w_wcol;
       }
-
       pum_anchor_grid = (int)curwin->w_grid.target->handle;
-      pum_win_row += curwin->w_grid.row_offset;
-      cursor_col += curwin->w_grid.col_offset;
-      if (!ui_has(kUIMultigrid) && curwin->w_grid.target != &default_grid) {
+    }
+
+    if (target_win != NULL) {
+      pum_win_row += target_win->w_grid.row_offset;
+      cursor_col += target_win->w_grid.col_offset;
+      if (!ui_has(kUIMultigrid) && target_win->w_grid.target != &default_grid) {
         pum_anchor_grid = (int)default_grid.handle;
-        pum_win_row += curwin->w_winrow;
-        cursor_col += curwin->w_wincol;
+        pum_win_row += target_win->w_winrow;
+        cursor_col += target_win->w_wincol;
       }
     }
 
@@ -221,16 +224,16 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
     int min_row = 0;
     int min_col = 0;
     int max_col = Columns;
-    int win_start_col = curwin->w_wincol;
-    int win_end_col = W_ENDCOL(curwin);
-    if (!(State & MODE_CMDLINE) && ui_has(kUIMultigrid)) {
-      above_row -= curwin->w_winrow;
-      below_row = MAX(below_row - curwin->w_winrow, curwin->w_grid.rows);
-      min_row = -curwin->w_winrow;
-      min_col = -curwin->w_wincol;
-      max_col = MAX(Columns - curwin->w_wincol, curwin->w_grid.cols);
+    int win_start_col = target_win ? target_win->w_wincol : 0;
+    int win_end_col = target_win ? W_ENDCOL(target_win) : 0;
+    if (target_win != NULL && ui_has(kUIMultigrid)) {
+      above_row -= target_win->w_winrow;
+      below_row = MAX(below_row - target_win->w_winrow, target_win->w_grid.rows);
+      min_row = -target_win->w_winrow;
+      min_col = -target_win->w_wincol;
+      max_col = MAX(Columns - target_win->w_wincol, target_win->w_grid.cols);
       win_start_col = 0;
-      win_end_col = curwin->w_grid.cols;
+      win_end_col = target_win->w_grid.cols;
     }
 
     // Figure out the size and position of the pum.
@@ -246,12 +249,12 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
       // pum above "pum_win_row"
       pum_above = true;
 
-      if (State == MODE_CMDLINE) {
-        // for cmdline pum, no need for context lines
+      if (State == MODE_CMDLINE && target_win == NULL) {
+        // For cmdline pum, no need for context lines unless target_win is set
         context_lines = 0;
       } else {
         // Leave two lines of context if possible
-        context_lines = MIN(2, curwin->w_wrow - curwin->w_cline_row);
+        context_lines = MIN(2, target_win->w_wrow - target_win->w_cline_row);
       }
 
       if (pum_win_row - min_row >= size + context_lines) {
@@ -270,14 +273,14 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
       // pum below "pum_win_row"
       pum_above = false;
 
-      if (State == MODE_CMDLINE) {
-        // for cmdline pum, no need for context lines
+      if (State == MODE_CMDLINE && target_win == NULL) {
+        // for cmdline pum, no need for context lines unless target_win is set
         context_lines = 0;
       } else {
         // Leave two lines of context if possible
-        validate_cheight(curwin);
-        int cline_visible_offset = curwin->w_cline_row +
-                                   curwin->w_cline_height - curwin->w_wrow;
+        validate_cheight(target_win);
+        int cline_visible_offset = target_win->w_cline_row +
+                                   target_win->w_cline_height - target_win->w_wrow;
         context_lines = MIN(3, cline_visible_offset);
       }
 

test/functional/lua/ui_event_spec.lua

@@ -306,6 +306,100 @@ describe('vim.ui_attach', function()
       },
     })
   end)
+
+  it('ext_cmdline completion popupmenu', function()
+    screen:try_resize(screen._width, 10)
+    screen:add_extra_attr_ids { [100] = { background = Screen.colors.Black } }
+    exec_lua([[
+      vim.o.wildoptions = 'pum'
+      local buf = vim.api.nvim_create_buf(false, true)
+      vim.cmd('call setline(1, range(1, 10))')
+      _G.win = vim.api.nvim_open_win(buf, false, {
+        relative = 'editor',
+        col = 3,
+        row = 3,
+        width = 20,
+        height = 1,
+        style = 'minimal',
+        focusable = false,
+        zindex = 300,
+        _cmdline_offset = 0,
+      })
+      vim.ui_attach(ns, { ext_cmdline = true }, function(event, content, _, firstc)
+        if event == 'cmdline_show' then
+          local prompt = vim.api.nvim_win_get_config(_G.win)._cmdline_offset == 0
+          prompt = (prompt and firstc or 'Excommand:') .. content[1][2]
+          vim.api.nvim_buf_set_lines(buf, -2, -1, false, { prompt })
+          vim.api.nvim_win_set_cursor(_G.win, { 1, #prompt })
+          vim.api.nvim__redraw({ win = _G.win, cursor = true, flush = true })
+        end
+        return true
+      end)
+      vim.api.nvim_set_hl(0, 'Pmenu', {})
+    ]])
+    feed(':call buf<tab>')
+    screen:expect([[
+      1                                       |
+      2                                       |
+      3                                       |
+      4  :call bufadd^(                        |
+      5       {12: bufadd(         }{100: }              |
+      6        bufexists(      {100: }              |
+      7        buffer_exists(  {12: }              |
+      8        buffer_name(    {12: }              |
+      9        buffer_number(  {12: }              |
+                                              |
+    ]])
+    exec_lua([[
+      vim.api.nvim_win_set_config(_G.win, {
+        relative = 'editor',
+        col = 0,
+        row = 1000,
+        width = 1000,
+        height = 1,
+      })
+    ]])
+    screen:expect([[
+      1                                       |
+      2                                       |
+      3                                       |
+      4                                       |
+      5       {12: bufadd(         }{100: }              |
+      6        bufexists(      {100: }              |
+      7        buffer_exists(  {12: }              |
+      8        buffer_name(    {12: }              |
+      9        buffer_number(  {12: }              |
+      :call bufadd^(                           |
+    ]])
+    feed('<tab>')
+    screen:expect([[
+      1     bufadd(         {100: }                 |
+      2    {12: bufexists(      }{100: }                 |
+      3     buffer_exists(  {100: }                 |
+      4     buffer_name(    {100: }                 |
+      5     buffer_number(  {100: }                 |
+      6     buflisted(      {100: }                 |
+      7     bufload(        {12: }                 |
+      8     bufloaded(      {12: }                 |
+      9     bufname(        {12: }                 |
+      :call bufexists^(                        |
+    ]])
+    -- Test different offset (e.g. for custom prompt)
+    exec_lua('vim.api.nvim_win_set_config(_G.win, { _cmdline_offset = 9 })')
+    feed('<Esc>:call buf<Tab>')
+    screen:expect([[
+      1             {12: bufadd(         }{100: }        |
+      2              bufexists(      {100: }        |
+      3              buffer_exists(  {100: }        |
+      4              buffer_name(    {100: }        |
+      5              buffer_number(  {100: }        |
+      6              buflisted(      {100: }        |
+      7              bufload(        {12: }        |
+      8              bufloaded(      {12: }        |
+      9              bufname(        {12: }        |
+      Excommand:call bufadd^(                  |
+    ]])
+  end)
 end)
 
 describe('vim.ui_attach', function()

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)

test/functional/ui/cmdline_spec.lua

@@ -623,8 +623,7 @@ local function test_cmdline(linegrid)
       { 'unplace', '', '', '' },
     }
 
-    command('set wildmode=full')
-    command('set wildmenu')
+    command('set wildmode=full wildmenu wildoptions=pum')
     screen:set_option('ext_popupmenu', true)
     feed(':sign <tab>')