neovim

_transport.lua (5276B)

---

local uv = vim.uv
local log = require('vim.lsp.log')

local is_win = vim.fn.has('win32') == 1

--- Checks whether a given path exists and is a directory.
---@param filename string path to check
---@return boolean
local function is_dir(filename)
 local stat = uv.fs_stat(filename)
 return stat and stat.type == 'directory' or false
end

--- @class (private) vim.lsp.rpc.Transport
--- @field write fun(self: vim.lsp.rpc.Transport, msg: string)
--- @field is_closing fun(self: vim.lsp.rpc.Transport): boolean
--- @field terminate fun(self: vim.lsp.rpc.Transport)

--- @class (private,exact) vim.lsp.rpc.Transport.Run : vim.lsp.rpc.Transport
--- @field new fun(): vim.lsp.rpc.Transport.Run
--- @field sysobj? vim.SystemObj
local TransportRun = {}

--- @return vim.lsp.rpc.Transport.Run
function TransportRun.new()
 return setmetatable({}, { __index = TransportRun })
end

--- @param cmd string[] Command to start the LSP server.
--- @param extra_spawn_params? vim.lsp.rpc.ExtraSpawnParams
--- @param on_read fun(err: any, data: string)
--- @param on_exit fun(code: integer, signal: integer)
function TransportRun:run(cmd, extra_spawn_params, on_read, on_exit)
 local function on_stderr(_, chunk)
   if chunk then
     log.error('rpc', cmd[1], 'stderr', chunk)
   end
 end

 extra_spawn_params = extra_spawn_params or {}

 if extra_spawn_params.cwd then
   assert(is_dir(extra_spawn_params.cwd), 'cwd must be a directory')
 end

 local detached = not is_win
 if extra_spawn_params.detached ~= nil then
   detached = extra_spawn_params.detached
 end

 local ok, sysobj_or_err = pcall(vim.system, cmd, {
   stdin = true,
   stdout = on_read,
   stderr = on_stderr,
   cwd = extra_spawn_params.cwd,
   env = extra_spawn_params.env,
   detach = detached,
 }, function(obj)
   on_exit(obj.code, obj.signal)
 end)

 if not ok then
   local err = sysobj_or_err --[[@as string]]
   local sfx = err:match('ENOENT')
       and '. The language server is either not installed, missing from PATH, or not executable.'
     or string.format(' with error message: %s', err)

   error(('Spawning language server with cmd: `%s` failed%s'):format(vim.inspect(cmd), sfx))
 end

 self.sysobj = sysobj_or_err --[[@as vim.SystemObj]]
end

function TransportRun:write(msg)
 assert(self.sysobj):write(msg)
end

function TransportRun:is_closing()
 return self.sysobj == nil or self.sysobj:is_closing()
end

function TransportRun:terminate()
 assert(self.sysobj):kill(15)
end

--- @class (private,exact) vim.lsp.rpc.Transport.Connect : vim.lsp.rpc.Transport
--- @field new fun(): vim.lsp.rpc.Transport.Connect
--- @field handle? uv.uv_pipe_t|uv.uv_tcp_t
--- Connect returns a PublicClient synchronously so the caller
--- can immediately send messages before the connection is established
--- -> Need to buffer them until that happens
--- @field connected boolean
--- @field closing boolean
--- @field msgbuf vim.Ringbuf
--- @field on_exit? fun(code: integer, signal: integer)
local TransportConnect = {}

--- @return vim.lsp.rpc.Transport.Connect
function TransportConnect.new()
 return setmetatable({
   connected = false,
   -- size should be enough because the client can't really do anything until initialization is done
   -- which required a response from the server - implying the connection got established
   msgbuf = vim.ringbuf(10),
   closing = false,
 }, { __index = TransportConnect })
end

--- @param host_or_path string
--- @param port? integer
--- @param on_read fun(err: any, data: string)
--- @param on_exit? fun(code: integer, signal: integer)
function TransportConnect:connect(host_or_path, port, on_read, on_exit)
 self.on_exit = on_exit
 self.handle = (
   port and assert(uv.new_tcp(), 'Could not create new TCP socket')
   or assert(uv.new_pipe(false), 'Pipe could not be opened.')
 )

 local function on_connect(err)
   if err then
     local address = not port and host_or_path or (host_or_path .. ':' .. port)
     vim.schedule(function()
       vim.notify(
         string.format('Could not connect to %s, reason: %s', address, vim.inspect(err)),
         vim.log.levels.WARN
       )
     end)
     return
   end
   self.handle:read_start(on_read)
   self.connected = true
   for msg in self.msgbuf do
     self.handle:write(msg)
   end
 end

 if not port then
   self.handle:connect(host_or_path, on_connect)
   return
 end

 --- @diagnostic disable-next-line:param-type-mismatch bad UV typing
 local info = uv.getaddrinfo(host_or_path, nil)
 local resolved_host = info and info[1] and info[1].addr or host_or_path
 self.handle:connect(resolved_host, port, on_connect)
end

function TransportConnect:write(msg)
 if self.connected then
   local _, err = self.handle:write(msg)
   if err and not self.closing then
     log.error('Error on handle:write: %q', err)
   end
   return
 end

 self.msgbuf:push(msg)
end

function TransportConnect:is_closing()
 return self.closing
end

function TransportConnect:terminate()
 if self.closing then
   return
 end
 self.closing = true
 if self.handle then
   self.handle:shutdown()
   self.handle:close()
 end
 if self.on_exit then
   self.on_exit(0, 0)
 end
end

return {
 TransportRun = TransportRun,
 TransportConnect = TransportConnect,
}