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
183
184
185
186
187
188
189
190
191
192
193
|
local config = require('blink.cmp.config')
local context = require('blink.cmp.completion.trigger.context')
local text_edits = {}
--- Applies one or more text edits to the current buffer, assuming utf-8 encoding
--- @param edits lsp.TextEdit[]
function text_edits.apply(edits)
local mode = context.get_mode()
if mode == 'default' then return vim.lsp.util.apply_text_edits(edits, vim.api.nvim_get_current_buf(), 'utf-8') end
assert(mode == 'cmdline', 'Unsupported mode for text edits: ' .. mode)
assert(#edits == 1, 'Cmdline mode only supports one text edit. Contributions welcome!')
local edit = edits[1]
local line = context.get_line()
local edited_line = line:sub(1, edit.range.start.character)
.. edit.newText
.. line:sub(edit.range['end'].character + 1)
-- FIXME: for some reason, we have to set the cursor here, instead of later,
-- because this will override the cursor position set later
vim.fn.setcmdline(edited_line, edit.range.start.character + #edit.newText + 1)
end
------- Undo -------
--- Gets the reverse of the text edit, must be called before applying
--- @param text_edit lsp.TextEdit
--- @return lsp.TextEdit
function text_edits.get_undo_text_edit(text_edit)
return {
range = text_edits.get_undo_range(text_edit),
newText = text_edits.get_text_to_replace(text_edit),
}
end
--- Gets the range for undoing an applied text edit
--- @param text_edit lsp.TextEdit
function text_edits.get_undo_range(text_edit)
text_edit = vim.deepcopy(text_edit)
local lines = vim.split(text_edit.newText, '\n')
local last_line_len = lines[#lines] and #lines[#lines] or 0
local range = text_edit.range
range['end'].line = range.start.line + #lines - 1
range['end'].character = #lines > 1 and last_line_len or range.start.character + last_line_len
return range
end
--- Gets the text the text edit will replace
--- @param text_edit lsp.TextEdit
--- @return string
function text_edits.get_text_to_replace(text_edit)
local lines = {}
for line = text_edit.range.start.line, text_edit.range['end'].line do
local line_text = context.get_line()
local is_start_line = line == text_edit.range.start.line
local is_end_line = line == text_edit.range['end'].line
if is_start_line and is_end_line then
table.insert(lines, line_text:sub(text_edit.range.start.character + 1, text_edit.range['end'].character))
elseif is_start_line then
table.insert(lines, line_text:sub(text_edit.range.start.character + 1))
elseif is_end_line then
table.insert(lines, line_text:sub(1, text_edit.range['end'].character))
else
table.insert(lines, line_text)
end
end
return table.concat(lines, '\n')
end
------- Get -------
--- Grabbed from vim.lsp.utils. Converts an offset_encoding to byte offset
--- @param position lsp.Position
--- @param offset_encoding? 'utf-8'|'utf-16'|'utf-32'
--- @return number
local function get_line_byte_from_position(position, offset_encoding)
local bufnr = vim.api.nvim_get_current_buf()
local col = position.character
-- When on the first character, we can ignore the difference between byte and character
if col == 0 then return 0 end
local line = vim.api.nvim_buf_get_lines(bufnr, position.line, position.line + 1, false)[1] or ''
if vim.fn.has('nvim-0.11.0') == 1 then
col = vim.str_byteindex(line, offset_encoding or 'utf-16', col, false) or 0
else
col = vim.lsp.util._str_byteindex_enc(line, col, offset_encoding or 'utf-16')
end
return math.min(col, #line)
end
--- Gets the text edit from an item, handling insert/replace ranges and converts
--- offset encodings (utf-16 | utf-32) to utf-8
--- @param item blink.cmp.CompletionItem
--- @return lsp.TextEdit
function text_edits.get_from_item(item)
local text_edit = vim.deepcopy(item.textEdit)
-- Guess the text edit if the item doesn't define it
if text_edit == nil then return text_edits.guess(item) end
-- FIXME: temporarily convert insertReplaceEdit to regular textEdit
if text_edit.range == nil then
if config.completion.keyword.range == 'full' and text_edit.replace ~= nil then
text_edit.range = text_edit.replace
else
text_edit.range = text_edit.insert or text_edit.replace
end
end
text_edit.insert = nil
text_edit.replace = nil
--- @cast text_edit lsp.TextEdit
-- Adjust the position of the text edit to be the current cursor position
-- since the data might be outdated. We compare the cursor column position
-- from when the items were fetched versus the current.
-- HACK: is there a better way?
-- TODO: take into account the offset_encoding
local offset = context.get_cursor()[2] - item.cursor_column
text_edit.range['end'].character = text_edit.range['end'].character + offset
-- convert the offset encoding to utf-8
-- TODO: we have to do this last because it applies a max on the position based on the length of the line
-- so it would break the offset code when removing characters at the end of the line
local offset_encoding = text_edits.offset_encoding_from_item(item)
text_edit = text_edits.to_utf_8(text_edit, offset_encoding)
text_edit.range = text_edits.clamp_range_to_bounds(text_edit.range)
return text_edit
end
function text_edits.offset_encoding_from_item(item)
local client = vim.lsp.get_client_by_id(item.client_id)
return client ~= nil and client.offset_encoding or 'utf-8'
end
function text_edits.to_utf_8(text_edit, offset_encoding)
if offset_encoding == 'utf-8' then return text_edit end
text_edit = vim.deepcopy(text_edit)
text_edit.range.start.character = get_line_byte_from_position(text_edit.range.start, offset_encoding)
text_edit.range['end'].character = get_line_byte_from_position(text_edit.range['end'], offset_encoding)
return text_edit
end
--- Uses the keyword_regex to guess the text edit ranges
--- @param item blink.cmp.CompletionItem
--- TODO: doesnt work when the item contains characters not included in the context regex
function text_edits.guess(item)
local word = item.insertText or item.label
local start_col, end_col = require('blink.cmp.fuzzy').guess_edit_range(
item,
context.get_line(),
context.get_cursor()[2],
config.completion.keyword.range
)
local current_line = context.get_cursor()[1]
-- convert to 0-index
return {
range = {
start = { line = current_line - 1, character = start_col },
['end'] = { line = current_line - 1, character = end_col },
},
newText = word,
}
end
--- Clamps the range to the bounds of their respective lines
--- @param range lsp.Range
--- @return lsp.Range
--- TODO: clamp start and end lines
function text_edits.clamp_range_to_bounds(range)
range = vim.deepcopy(range)
local start_line = context.get_line(range.start.line)
range.start.character = math.min(math.max(range.start.character, 0), #start_line)
local end_line = context.get_line(range['end'].line)
range['end'].character = math.min(
math.max(range['end'].character, range.start.line == range['end'].line and range.start.character or 0),
#end_line
)
return range
end
return text_edits
|
