1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
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,
}
|
