333 lines
9.8 KiB
Lua
333 lines
9.8 KiB
Lua
local kind = require("lsp.kind")
|
|
local util = require("util")
|
|
|
|
local REQUEST_DEBOUNCE_MS = 100
|
|
|
|
--- Normalize an `itemDefaults.editRange` to a plain Range, since it may be
|
|
--- either `Range` or `{ insert: Range, replace: Range }`.
|
|
---@param edit_range table?
|
|
---@return table?
|
|
local function default_range(edit_range)
|
|
if type(edit_range) ~= "table" then
|
|
return nil
|
|
end
|
|
return edit_range.insert or (edit_range.start and edit_range) or nil
|
|
end
|
|
|
|
--- Normalize an item's `textEdit`, which may be `TextEdit` (has `range`) or
|
|
--- `InsertReplaceEdit` (has `insert`/`replace`).
|
|
---@param item lsp.CompletionItem
|
|
---@return table?
|
|
local function item_range(item)
|
|
local te = item.textEdit
|
|
if type(te) ~= "table" then
|
|
return nil
|
|
end
|
|
return te.range or te.insert
|
|
end
|
|
|
|
---@param response table LSP response entry (as returned by buf_request_all)
|
|
---@return integer? character 0-indexed UTF-16 character where edit starts
|
|
local function response_edit_start(response)
|
|
if not response.result or response.err or response.error then
|
|
return nil
|
|
end
|
|
local defaults =
|
|
default_range(vim.tbl_get(response.result, "itemDefaults", "editRange"))
|
|
if defaults then
|
|
return defaults.start.character
|
|
end
|
|
local items = response.result.items or response.result
|
|
if type(items) ~= "table" then
|
|
return nil
|
|
end
|
|
for _, item in ipairs(items) do
|
|
local range = item_range(item)
|
|
if range then
|
|
return range.start.character
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---@param item lsp.CompletionItem
|
|
---@return string
|
|
local function item_word(item)
|
|
local edit = item.textEdit
|
|
if type(edit) == "table" and edit.newText then
|
|
return edit.newText
|
|
end
|
|
return item.insertText or item.label
|
|
end
|
|
|
|
---@param items lsp.CompletionItem[]
|
|
---@param defaults? table
|
|
local function apply_defaults(items, defaults)
|
|
if type(defaults) ~= "table" then
|
|
return
|
|
end
|
|
local range = default_range(defaults.editRange)
|
|
for _, item in ipairs(items) do
|
|
item.commitCharacters = item.commitCharacters
|
|
or defaults.commitCharacters
|
|
item.data = item.data or defaults.data
|
|
item.insertTextFormat = item.insertTextFormat
|
|
or defaults.insertTextFormat
|
|
item.insertTextMode = item.insertTextMode or defaults.insertTextMode
|
|
if range and type(item.textEdit) ~= "table" then
|
|
item.textEdit = {
|
|
range = range,
|
|
newText = item.textEditText or item.insertText or item.label,
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
--- Transform raw LSP completion responses into Vim |complete()| items,
|
|
--- filtered by `base` and sorted by sortText/label.
|
|
---@param responses table map of client_id -> response from buf_request_all
|
|
---@param base string
|
|
---@return table[]
|
|
local function build_items(responses, base)
|
|
local entries = {}
|
|
for client_id, response in pairs(responses) do
|
|
if response.result and not (response.err or response.error) then
|
|
local raw = response.result.items or response.result
|
|
if type(raw) == "table" then
|
|
apply_defaults(raw, response.result.itemDefaults)
|
|
for _, item in ipairs(raw) do
|
|
entries[#entries + 1] =
|
|
{ item = item, client_id = client_id }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if base ~= "" then
|
|
entries = vim.tbl_filter(function(entry)
|
|
local key = entry.item.filterText or entry.item.label
|
|
return vim.startswith(key, base)
|
|
end, entries)
|
|
end
|
|
|
|
table.sort(entries, function(a, b)
|
|
local ka = a.item.sortText or a.item.label
|
|
local kb = b.item.sortText or b.item.label
|
|
return ka < kb
|
|
end)
|
|
|
|
local result = {}
|
|
for _, entry in ipairs(entries) do
|
|
local item = entry.item
|
|
local kind_icon, kind_hl = kind.get(item.kind)
|
|
result[#result + 1] = {
|
|
word = item_word(item),
|
|
abbr = item.label:match("[^(]+") or item.label,
|
|
menu = vim.tbl_get(item, "labelDetails", "detail") or "",
|
|
kind = kind_icon,
|
|
kind_hlgroup = kind_hl,
|
|
-- non-empty so our CompleteChanged handler triggers resolve
|
|
info = " ",
|
|
icase = 1,
|
|
dup = 1,
|
|
empty = 1,
|
|
user_data = {
|
|
nvim = {
|
|
lsp = {
|
|
completion_item = item,
|
|
client_id = entry.client_id,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
end
|
|
return result
|
|
end
|
|
|
|
local function buffer_has_completion_client()
|
|
return #vim.lsp.get_clients({
|
|
bufnr = 0,
|
|
method = vim.lsp.protocol.Methods.textDocument_completion,
|
|
}) > 0
|
|
end
|
|
|
|
---@param char string
|
|
---@return boolean
|
|
local function is_trigger_char(char)
|
|
local clients = vim.lsp.get_clients({
|
|
bufnr = 0,
|
|
method = vim.lsp.protocol.Methods.textDocument_completion,
|
|
})
|
|
for _, client in ipairs(clients) do
|
|
local chars = vim.tbl_get(
|
|
client,
|
|
"server_capabilities",
|
|
"completionProvider",
|
|
"triggerCharacters"
|
|
)
|
|
if chars and vim.list_contains(chars, char) then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function feed_omnifunc()
|
|
if vim.fn.mode() ~= "i" or vim.fn.pumvisible() ~= 0 then
|
|
return
|
|
end
|
|
vim.api.nvim_feedkeys(vim.keycode("<C-x><C-o>"), "n", false)
|
|
end
|
|
|
|
---@class ow.lsp.completion.Request
|
|
---@field private generation integer
|
|
---@field private phase ('awaiting' | 'ready' | 'done')?
|
|
---@field private result table?
|
|
---@field private cancel function?
|
|
local Request = {}
|
|
Request.__index = Request
|
|
|
|
---@return ow.lsp.completion.Request
|
|
function Request.new()
|
|
return setmetatable({
|
|
generation = 0,
|
|
phase = nil,
|
|
result = nil,
|
|
cancel = nil,
|
|
}, Request)
|
|
end
|
|
|
|
---@return boolean
|
|
function Request:is_awaiting()
|
|
return self.phase == "awaiting"
|
|
end
|
|
|
|
---@return boolean
|
|
function Request:is_ready()
|
|
return self.phase == "ready"
|
|
end
|
|
|
|
--- Cancel any in-flight LSP request and clear cached results.
|
|
function Request:discard()
|
|
if self.cancel then
|
|
pcall(self.cancel)
|
|
end
|
|
self.generation = self.generation + 1
|
|
self.phase = nil
|
|
self.result = nil
|
|
self.cancel = nil
|
|
end
|
|
|
|
---@param trigger_kind integer
|
|
---@param trigger_char string?
|
|
function Request:dispatch(trigger_kind, trigger_char)
|
|
self:discard()
|
|
self.phase = "awaiting"
|
|
local gen = self.generation
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local params = vim.lsp.util.make_position_params(0, "utf-16")
|
|
---@cast params lsp.CompletionParams
|
|
params.context = {
|
|
triggerKind = trigger_kind,
|
|
triggerCharacter = trigger_char,
|
|
}
|
|
self.cancel = vim.lsp.buf_request_all(
|
|
buf,
|
|
vim.lsp.protocol.Methods.textDocument_completion,
|
|
params,
|
|
function(result)
|
|
if self.generation ~= gen or self.phase ~= "awaiting" then
|
|
return
|
|
end
|
|
self.phase = "ready"
|
|
self.result = result
|
|
feed_omnifunc()
|
|
end
|
|
)
|
|
end
|
|
|
|
--- Byte column where the cached LSP edits start, for |complete-functions|
|
|
--- `findstart == 1`. Falls back to the regex end of the word under cursor.
|
|
---@return integer
|
|
function Request:start_col()
|
|
for _, response in pairs(self.result or {}) do
|
|
local col = response_edit_start(response)
|
|
if col then
|
|
return col
|
|
end
|
|
end
|
|
local line = vim.api.nvim_get_current_line()
|
|
local cursor_col = vim.fn.col(".") - 1
|
|
return vim.fn.match(line:sub(1, cursor_col), "\\k*$")
|
|
end
|
|
|
|
--- Build the Vim |complete()| items from the cached LSP results filtered by
|
|
--- `base`, and transition this request to the "done" phase. Subsequent
|
|
--- completion triggers will dispatch a fresh request.
|
|
---@param base string
|
|
---@return table[]
|
|
function Request:consume(base)
|
|
local items = build_items(self.result or {}, base)
|
|
self.phase = "done"
|
|
return items
|
|
end
|
|
|
|
local request = Request.new()
|
|
|
|
local debounce = util.debounce(function(_, trigger_kind, char)
|
|
if vim.fn.mode() ~= "i" then
|
|
return
|
|
end
|
|
request:dispatch(trigger_kind, char)
|
|
end, REQUEST_DEBOUNCE_MS)
|
|
|
|
local M = {}
|
|
|
|
function M.on_insert_char_pre()
|
|
local char = vim.v.char
|
|
if char == "" then
|
|
return
|
|
end
|
|
local is_word = char:match("[%w_]") ~= nil
|
|
local is_trigger = not is_word and is_trigger_char(char)
|
|
if not (is_word or is_trigger) then
|
|
return
|
|
end
|
|
-- For word chars, let Vim's native in-place filtering handle things while
|
|
-- the pum is already showing. Trigger chars always schedule a request
|
|
-- because they change the completion context (e.g. member access).
|
|
if is_word and vim.fn.pumvisible() ~= 0 then
|
|
return
|
|
end
|
|
|
|
local kind_num = is_trigger
|
|
and vim.lsp.protocol.CompletionTriggerKind.TriggerCharacter
|
|
or vim.lsp.protocol.CompletionTriggerKind.Invoked
|
|
debounce:call(nil, kind_num, is_trigger and char or nil)
|
|
end
|
|
|
|
-- Global entry point for Vim's 'omnifunc' option. Referenced via
|
|
-- `v:lua.ow_lsp_completion.omnifunc` from on_attach's `vim.bo.omnifunc`.
|
|
_G.ow_lsp_completion = _G.ow_lsp_completion or {}
|
|
|
|
--- Returns cached items without re-requesting, which is what lets Vim filter
|
|
--- the popup in-place on backspace.
|
|
---@param findstart 0 | 1
|
|
---@param base string
|
|
---@return integer | table
|
|
function _G.ow_lsp_completion.omnifunc(findstart, base)
|
|
if not buffer_has_completion_client() or request:is_awaiting() then
|
|
return findstart == 1 and -3 or {}
|
|
end
|
|
if not request:is_ready() then
|
|
request:dispatch(vim.lsp.protocol.CompletionTriggerKind.Invoked)
|
|
return findstart == 1 and -3 or {}
|
|
end
|
|
if findstart == 1 then
|
|
return request:start_col()
|
|
end
|
|
return request:consume(base)
|
|
end
|
|
|
|
return M
|