diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt index 024c9433a1..625079bf8f 100644 --- a/runtime/doc/lua.txt +++ b/runtime/doc/lua.txt @@ -4259,25 +4259,32 @@ by |vim.Pos| objects. See |Pos:to_lsp()|. • {lsp} (`fun(buf: integer, pos: lsp.Position, position_encoding: lsp.PositionEncodingKind)`) See |Pos:lsp()|. - • {to_cursor} (`fun(pos: vim.Pos): [integer, integer]`) See + • {to_cursor} (`fun(pos: vim.Pos): integer, integer`) See |Pos:to_cursor()|. - • {cursor} (`fun(pos: [integer, integer])`) See |Pos:cursor()|. - • {to_extmark} (`fun(pos: vim.Pos): [integer, integer]`) See + • {cursor} (`fun(pos: [integer, integer], opts: vim.Pos.Optional?)`) + See |Pos:cursor()|. + • {to_extmark} (`fun(pos: vim.Pos): integer, integer`) See |Pos:to_extmark()|. - • {extmark} (`fun(pos: [integer, integer])`) See |Pos:extmark()|. + • {extmark} (`fun(row: integer, col: integer, opts: vim.Pos.Optional?)`) + See |Pos:extmark()|. -Pos:cursor({pos}) *Pos:cursor()* - Creates a new |vim.Pos| from cursor position. +Pos:cursor({pos}, {opts}) *Pos:cursor()* + Creates a new |vim.Pos| from cursor position (see |api-indexing|). Parameters: ~ - • {pos} (`[integer, integer]`) + • {pos} (`[integer, integer]`) + • {opts} (`table?`) A table with the following fields: + • {buf}? (`integer`) -Pos:extmark({pos}) *Pos:extmark()* - Creates a new |vim.Pos| from extmark position. +Pos:extmark({row}, {col}, {opts}) *Pos:extmark()* + Creates a new |vim.Pos| from extmark position (see |api-indexing|). Parameters: ~ - • {pos} (`[integer, integer]`) + • {row} (`integer`) + • {col} (`integer`) + • {opts} (`table?`) A table with the following fields: + • {buf}? (`integer`) Pos:lsp({buf}, {pos}, {position_encoding}) *Pos:lsp()* Creates a new |vim.Pos| from `lsp.Position`. @@ -4299,22 +4306,24 @@ Pos:lsp({buf}, {pos}, {position_encoding}) *Pos:lsp()* • {position_encoding} (`lsp.PositionEncodingKind`) Pos:to_cursor({pos}) *Pos:to_cursor()* - Converts |vim.Pos| to cursor position. + Converts |vim.Pos| to cursor position (see |api-indexing|). Parameters: ~ • {pos} (`vim.Pos`) See |vim.Pos|. - Return: ~ - (`[integer, integer]`) + Return (multiple): ~ + (`integer`) + (`integer`) Pos:to_extmark({pos}) *Pos:to_extmark()* - Converts |vim.Pos| to extmark position. + Converts |vim.Pos| to extmark position (see |api-indexing|). Parameters: ~ • {pos} (`vim.Pos`) See |vim.Pos|. - Return: ~ - (`[integer, integer]`) + Return (multiple): ~ + (`integer`) + (`integer`) Pos:to_lsp({pos}, {position_encoding}) *Pos:to_lsp()* Converts |vim.Pos| to `lsp.Position`. @@ -4361,7 +4370,8 @@ Provides operations to compare, calculate, and convert ranges represented by local range2 = vim.range(3, 5, 4, 0) -- Because `vim.Range` is end exclusive, `range1` and `range2` both represent - -- a range starting at the row 3, column 5 and ending at where the row 3 ends. + -- a range starting at the row 3, column 5 and ending at where the row 3 ends + -- (including the newline at the end of line 3). -- Operators are overloaded for comparing two `vim.Pos` objects. if range1 == range2 then @@ -4374,18 +4384,69 @@ Provides operations to compare, calculate, and convert ranges represented by have the same optional fields. Fields: ~ - • {start} (`vim.Pos`) Start position. - • {end_} (`vim.Pos`) End position, exclusive. - • {is_empty} (`fun(self: vim.Range): boolean`) See |Range:is_empty()|. - • {has} (`fun(outer: vim.Range, inner: vim.Range|vim.Pos): boolean`) - See |Range:has()|. - • {intersect} (`fun(r1: vim.Range, r2: vim.Range): vim.Range?`) See - |Range:intersect()|. - • {to_lsp} (`fun(range: vim.Range, position_encoding: lsp.PositionEncodingKind): lsp.Range`) - See |Range:to_lsp()|. - • {lsp} (`fun(buf: integer, range: lsp.Range, position_encoding: lsp.PositionEncodingKind)`) - See |Range:lsp()|. + • {start_row} (`integer`) 0-based byte index. + • {start_col} (`integer`) 0-based byte index. + • {end_row} (`integer`) 0-based byte index. + • {end_col} (`integer`) 0-based byte index. + • {buf}? (`integer`) Optional buffer handle. + When specified, it indicates that this range belongs to + a specific buffer. This field is required when + performing range conversions. + • {is_empty} (`fun(self: vim.Range): boolean`) See + |Range:is_empty()|. + • {has} (`fun(outer: vim.Range, inner: vim.Range|vim.Pos): boolean`) + See |Range:has()|. + • {intersect} (`fun(r1: vim.Range, r2: vim.Range): vim.Range?`) See + |Range:intersect()|. + • {to_lsp} (`fun(range: vim.Range, position_encoding: lsp.PositionEncodingKind): lsp.Range`) + See |Range:to_lsp()|. + • {lsp} (`fun(buf: integer, range: lsp.Range, position_encoding: lsp.PositionEncodingKind)`) + See |Range:lsp()|. + • {to_extmark} (`fun(range: vim.Range)`) See |Range:to_extmark()|. + • {extmark} (`fun(start_row: integer, start_col: integer, end_row: integer, end_col: integer, opts: vim.Pos.Optional?)`) + See |Range:extmark()|. + • {to_cursor} (`fun(range: vim.Range)`) See |Range:to_cursor()|. + • {cursor} (`fun(buf: integer, start_pos: [integer, integer], end_pos: [integer, integer], opts: vim.Pos.Optional?)`) + See |Range:cursor()|. + + +Range:cursor({buf}, {start_pos}, {end_pos}, {opts}) *Range:cursor()* + Creates a new |vim.Range| from mark-like range (see |api-indexing|). + + Example: >lua + local buf = vim.api.nvim_get_current_buf() + local start = vim.api.nvim_win_get_cursor(0) + -- move the cursor + local end_ = vim.api.nvim_win_get_cursor(0) + + local range = vim.range.cursor(start, end_, { buf = buf }) +< + + Parameters: ~ + • {buf} (`integer`) + • {start_pos} (`[integer, integer]`) + • {end_pos} (`[integer, integer]`) + • {opts} (`table?`) A table with the following fields: + • {buf}? (`integer`) + + *Range:extmark()* +Range:extmark({start_row}, {start_col}, {end_row}, {end_col}, {opts}) + Creates a new |vim.Range| from extmark range (see |api-indexing|). + + Example: >lua + local buf = vim.api.nvim_get_current_buf() + + local range = vim.range.extmark(3, 5, 4, 0, { buf = buf }) +< + + Parameters: ~ + • {start_row} (`integer`) + • {start_col} (`integer`) + • {end_row} (`integer`) + • {end_col} (`integer`) + • {opts} (`table?`) A table with the following fields: + • {buf}? (`integer`) Range:has({outer}, {inner}) *Range:has()* Checks whether {outer} range contains {inner} range or position. @@ -4434,6 +4495,36 @@ Range:lsp({buf}, {range}, {position_encoding}) *Range:lsp()* • {range} (`lsp.Range`) • {position_encoding} (`lsp.PositionEncodingKind`) +Range:to_cursor({range}) *Range:to_cursor()* + Converts |vim.Range| to mark-like range (see |api-indexing|). + + Example: >lua + -- `buf` is required for conversion to extmark range. + local buf = vim.api.nvim_get_current_buf() + local range = vim.range(3, 5, 4, 0, { buf = buf }) + + -- Convert to cursor range, you can call it in a method style. + local cursor_range = range:to_cursor() +< + + Parameters: ~ + • {range} (`vim.Range`) See |vim.Range|. + +Range:to_extmark({range}) *Range:to_extmark()* + Converts |vim.Range| to extmark range (see |api-indexing|). + + Example: >lua + -- `buf` is required for conversion to extmark range. + local buf = vim.api.nvim_get_current_buf() + local range = vim.range(3, 5, 4, 0, { buf = buf }) + + -- Convert to extmark range, you can call it in a method style. + local extmark_range = range:to_extmark() +< + + Parameters: ~ + • {range} (`vim.Range`) See |vim.Range|. + Range:to_lsp({range}, {position_encoding}) *Range:to_lsp()* Converts |vim.Range| to `lsp.Range`. diff --git a/runtime/lua/vim/lsp/codelens.lua b/runtime/lua/vim/lsp/codelens.lua index 669d601efb..30b4c4a8ca 100644 --- a/runtime/lua/vim/lsp/codelens.lua +++ b/runtime/lua/vim/lsp/codelens.lua @@ -240,7 +240,7 @@ function Provider:on_win(toprow, botrow) local range = vim.range.lsp(bufnr, lenses[1].range, client.offset_encoding) ---@type [string, string][] local virt_text = { - { string.rep(' ', range.start.col), 'LspCodeLensSeparator' }, + { string.rep(' ', range.start_col), 'LspCodeLensSeparator' }, } for _, lens in ipairs(lenses) do diff --git a/runtime/lua/vim/lsp/document_color.lua b/runtime/lua/vim/lsp/document_color.lua index e31b500e8e..ab87e02afe 100644 --- a/runtime/lua/vim/lsp/document_color.lua +++ b/runtime/lua/vim/lsp/document_color.lua @@ -266,11 +266,11 @@ api.nvim_set_decoration_provider(document_color_ns, { api.nvim_buf_set_extmark( bufnr, state.namespace, - hl.range.start.row, - hl.range.start.col, + hl.range.start_row, + hl.range.start_col, { - end_row = hl.range.end_.row, - end_col = hl.range.end_.col, + end_row = hl.range.end_row, + end_col = hl.range.end_col, hl_group = hl.hl_group, strict = false, } @@ -281,8 +281,8 @@ api.nvim_set_decoration_provider(document_color_ns, { api.nvim_buf_set_extmark( bufnr, state.namespace, - hl.range.start.row, - hl.range.start.col, + hl.range.start_row, + hl.range.start_col, { virt_text = { { swatch, hl.hl_group } }, virt_text_pos = 'inline', diff --git a/runtime/lua/vim/lsp/inline_completion.lua b/runtime/lua/vim/lsp/inline_completion.lua index ddf02f2c27..e0513a13f0 100644 --- a/runtime/lua/vim/lsp/inline_completion.lua +++ b/runtime/lua/vim/lsp/inline_completion.lua @@ -219,9 +219,12 @@ function Completor:show(hint) table.insert(lines[#lines], { hint, 'ComplHintMore' }) end - local pos = current.range and current.range.start:to_extmark() - or vim.pos.cursor(api.nvim_win_get_cursor(vim.fn.bufwinid(self.bufnr))):to_extmark() - local row, col = unpack(pos) + local row, col ---@type integer, integer + if current.range then + row, col = current.range:to_extmark() + else + row, col = vim.pos.cursor(api.nvim_win_get_cursor(vim.fn.bufwinid(self.bufnr))):to_extmark() + end -- To ensure that virtual text remains visible continuously (without flickering) -- while the user is editing the buffer, we allow displaying expired virtual text. @@ -242,7 +245,7 @@ function Completor:show(hint) -- At least, characters before the cursor should be skipped. if api.nvim_win_get_buf(winid) == self.bufnr then local cursor_row, cursor_col = - unpack(vim.pos.cursor(api.nvim_win_get_cursor(winid)):to_extmark()) + vim.pos.cursor(api.nvim_win_get_cursor(winid), { buf = self.bufnr }):to_extmark() if row == cursor_row then skip = math.max(skip, cursor_col - col + 1) end @@ -338,23 +341,16 @@ end function Completor:accept(item) local insert_text = item.insert_text if type(insert_text) == 'string' then - local range = item.range - if range then + if item.range then + local start_row, start_col, end_row, end_col = item.range:to_extmark() local lines = vim.split(insert_text, '\n') - api.nvim_buf_set_text( - self.bufnr, - range.start.row, - range.start.col, - range.end_.row, - range.end_.col, - lines - ) - local pos = item.range.start:to_cursor() + api.nvim_buf_set_text(self.bufnr, start_row, start_col, end_row, end_col, lines) local win = api.nvim_get_current_win() win = api.nvim_win_get_buf(win) == self.bufnr and win or vim.fn.bufwinid(self.bufnr) + local row, col = item.range:to_cursor() api.nvim_win_set_cursor(win, { - pos[1] + #lines - 1, - (#lines == 1 and pos[2] or 0) + #lines[#lines], + row + #lines - 1, + (#lines == 1 and col or 0) + #lines[#lines], }) else api.nvim_paste(insert_text, false, 0) diff --git a/runtime/lua/vim/pos.lua b/runtime/lua/vim/pos.lua index cb793053a2..5f704a4f5d 100644 --- a/runtime/lua/vim/pos.lua +++ b/runtime/lua/vim/pos.lua @@ -42,8 +42,25 @@ local validate = vim.validate --- When specified, it indicates that this position belongs to a specific buffer. --- This field is required when performing position conversions. ---@field buf? integer +---@field private [1] integer underlying representation of row +---@field private [2] integer underlying representation of col +---@field private [3] integer underlying representation of buf local Pos = {} -Pos.__index = Pos + +---@private +---@param pos vim.Pos +---@param key any +function Pos.__index(pos, key) + if key == 'row' then + return pos[1] + elseif key == 'col' then + return pos[2] + elseif key == 'buf' then + return pos[3] + end + + return Pos[key] +end ---@class vim.Pos.Optional ---@inlinedoc @@ -62,9 +79,9 @@ function Pos.new(row, col, opts) ---@type vim.Pos local self = setmetatable({ - row = row, - col = col, - buf = opts.buf, + row, + col, + opts.buf, }, Pos) return self @@ -176,31 +193,42 @@ function Pos.lsp(buf, pos, position_encoding) return Pos.new(row, col, { buf = buf }) end ---- Converts |vim.Pos| to cursor position. +--- Converts |vim.Pos| to cursor position (see |api-indexing|). ---@param pos vim.Pos ----@return [integer, integer] +---@return integer, integer function Pos.to_cursor(pos) - return { pos.row + 1, pos.col } + return pos.row + 1, pos.col end ---- Creates a new |vim.Pos| from cursor position. +--- Creates a new |vim.Pos| from cursor position (see |api-indexing|). ---@param pos [integer, integer] -function Pos.cursor(pos) - return Pos.new(pos[1] - 1, pos[2]) +---@param opts vim.Pos.Optional|nil +function Pos.cursor(pos, opts) + return Pos.new(pos[1] - 1, pos[2], opts) end ---- Converts |vim.Pos| to extmark position. +--- Converts |vim.Pos| to extmark position (see |api-indexing|). ---@param pos vim.Pos ----@return [integer, integer] +---@return integer, integer function Pos.to_extmark(pos) - return { pos.row, pos.col } + local line_num = #api.nvim_buf_get_lines(pos.buf, 0, -1, true) + + local row = pos.row + local col = pos.col + if pos.col == 0 and pos.row == line_num then + row = row - 1 + col = #get_line(pos.buf, row) + end + + return row, col end ---- Creates a new |vim.Pos| from extmark position. ----@param pos [integer, integer] -function Pos.extmark(pos) - local row, col = unpack(pos) - return Pos.new(row, col) +--- Creates a new |vim.Pos| from extmark position (see |api-indexing|). +---@param row integer +---@param col integer +---@param opts vim.Pos.Optional|nil +function Pos.extmark(row, col, opts) + return Pos.new(row, col, opts) end -- Overload `Range.new` to allow calling this module as a function. diff --git a/runtime/lua/vim/range.lua b/runtime/lua/vim/range.lua index f0cd01145e..78e201e3fd 100644 --- a/runtime/lua/vim/range.lua +++ b/runtime/lua/vim/range.lua @@ -8,6 +8,7 @@ --- objects. local validate = vim.validate +local api = vim.api --- Represents a well-defined range. --- @@ -26,7 +27,8 @@ local validate = vim.validate --- local range2 = vim.range(3, 5, 4, 0) --- --- -- Because `vim.Range` is end exclusive, `range1` and `range2` both represent ---- -- a range starting at the row 3, column 5 and ending at where the row 3 ends. +--- -- a range starting at the row 3, column 5 and ending at where the row 3 ends +--- -- (including the newline at the end of line 3). --- --- -- Operators are overloaded for comparing two `vim.Pos` objects. --- if range1 == range2 then @@ -39,71 +41,161 @@ local validate = vim.validate --- need to have the same optional fields. --- ---@class vim.Range ----@field start vim.Pos Start position. ----@field end_ vim.Pos End position, exclusive. +---@field start_row integer 0-based byte index. +---@field start_col integer 0-based byte index. +---@field end_row integer 0-based byte index. +---@field end_col integer 0-based byte index. +--- +--- Optional buffer handle. +--- +--- When specified, it indicates that this range belongs to a specific buffer. +--- This field is required when performing range conversions. +---@field buf? integer +---@field private [1] integer underlying representation of start_row +---@field private [2] integer underlying representation of start_col +---@field private [3] integer underlying representation of end_row +---@field private [4] integer underlying representation of end_col local Range = {} -Range.__index = Range + +---@private +---@param pos vim.Range +---@param key any +function Range.__index(pos, key) + if key == 'start_row' then + return pos[1] + elseif key == 'start_col' then + return pos[2] + elseif key == 'end_row' then + return pos[3] + elseif key == 'end_col' then + return pos[4] + elseif key == 'buf' then + return pos[5] + end + + return Range[key] +end ---@package ---@overload fun(self: vim.Range, start: vim.Pos, end_: vim.Pos): vim.Range ---@overload fun(self: vim.Range, start_row: integer, start_col: integer, end_row: integer, end_col: integer, opts?: vim.Pos.Optional): vim.Range function Range.new(...) - ---@type vim.Pos, vim.Pos, vim.Pos.Optional - local start, end_ + ---@type integer, integer, integer, integer, integer|nil + local start_row, start_col, end_row, end_col, buf local nargs = select('#', ...) if nargs == 2 then ---@type vim.Pos, vim.Pos - start, end_ = ... + local start, end_ = ... validate('start', start, 'table') validate('end_', end_, 'table') if start.buf ~= end_.buf then error('start and end positions must belong to the same buffer') end + start_row, start_col, end_row, end_col, buf = + start.row, start.col, end_.row, end_.col, start.buf elseif nargs == 4 or nargs == 5 then - ---@type integer, integer, integer, integer, vim.Pos.Optional - local start_row, start_col, end_row, end_col, opts = ... - start, end_ = vim.pos(start_row, start_col, opts), vim.pos(end_row, end_col, opts) + local opts + ---@type integer, integer, integer, integer, vim.Pos.Optional|nil + start_row, start_col, end_row, end_col, opts = ... + buf = opts and opts.buf else error('invalid parameters') end ---@type vim.Range local self = setmetatable({ - start = start, - end_ = end_, + start_row, + start_col, + end_row, + end_col, + buf, }, Range) return self end +--- TODO(ofseed): Make it work for unloaded buffers. Check get_line() in vim.lsp.util. +---@param buf integer +---@param row integer +local function get_line(buf, row) + return api.nvim_buf_get_lines(buf, row, row + 1, true)[1] +end + +---@param p1_row integer Row of first position to compare. +---@param p1_col integer Col of first position to compare. +---@param p2_row integer Row of second position to compare. +---@param p2_col integer Col of second position to compare. +---@return integer +--- 1: a > b +--- 0: a == b +--- -1: a < b +local function cmp_pos(p1_row, p1_col, p2_row, p2_col) + if p1_row == p2_row then + if p1_col > p2_col then + return 1 + elseif p1_col < p2_col then + return -1 + else + return 0 + end + elseif p1_row > p2_row then + return 1 + end + + return -1 +end + +---@param row integer +---@param col integer +---@param buf integer +---@return integer, integer +local function to_inclusive_pos(row, col, buf) + if col > 0 then + col = col - 1 + elseif col == 0 and row > 0 then + row = row - 1 + col = #get_line(buf, row) + end + + return row, col +end + ---@private ---@param r1 vim.Range ---@param r2 vim.Range function Range.__lt(r1, r2) - return r1.end_ < r2.start + local r1_inclusive_end_row, r1_inclusive_end_col = + to_inclusive_pos(r1.end_row, r1.end_col, r1.buf) + return cmp_pos(r1_inclusive_end_row, r1_inclusive_end_col, r2.start_row, r2.start_col) == -1 end ---@private ---@param r1 vim.Range ---@param r2 vim.Range function Range.__le(r1, r2) - return r1.end_ <= r2.start + local r1_inclusive_end_row, r1_inclusive_end_col = + to_inclusive_pos(r1.end_row, r1.end_col, r1.buf) + return cmp_pos(r1_inclusive_end_row, r1_inclusive_end_col, r2.start_row, r2.start_col) ~= 1 end ---@private ---@param r1 vim.Range ---@param r2 vim.Range function Range.__eq(r1, r2) - return r1.start == r2.start and r1.end_ == r2.end_ + return cmp_pos(r1.start_row, r1.start_col, r2.start_row, r2.start_col) == 0 + and cmp_pos(r1.end_row, r1.end_col, r2.end_row, r2.end_col) == 0 end --- Checks whether the given range is empty; i.e., start >= end. --- ---@return boolean `true` if the given range is empty function Range:is_empty() - return self.start >= self.end_ + local inclusive_end_row, inclusive_end_col = + to_inclusive_pos(self.end_row, self.end_col, self.buf) + + return cmp_pos(self.start_row, self.start_col, inclusive_end_row, inclusive_end_col) ~= -1 end --- Checks whether {outer} range contains {inner} range or position. @@ -112,13 +204,30 @@ end ---@param inner vim.Range|vim.Pos ---@return boolean `true` if {outer} range fully contains {inner} range or position. function Range.has(outer, inner) - if inner.start then - -- inner is a range - return outer.start <= inner.start and outer.end_ >= inner.end_ - else - -- inner is a position - return outer.start <= inner and outer.end_ >= inner + if getmetatable(inner) == vim.pos then + ---@cast inner -vim.Range + return cmp_pos(outer.start_row, outer.start_col, inner.row, inner.col) ~= 1 + and cmp_pos(outer.end_row, outer.end_col, inner.row, inner.col) ~= -1 end + ---@cast inner -vim.Pos + + local outer_inclusive_end_row, outer_inclusive_end_col = + to_inclusive_pos(outer.end_row, outer.end_col, outer.buf) + local inner_inclusive_end_row, inner_inclusive_end_col = + to_inclusive_pos(inner.end_row, inner.end_col, inner.buf) + + return cmp_pos(outer.start_row, outer.start_col, inner.start_row, inner.start_col) ~= 1 + and cmp_pos(outer.end_row, outer.end_col, inner.end_row, inner.end_col) ~= -1 + -- accounts for empty ranges at the start/end of `outer` that per Neovim API and LSP logic + -- insert the text outside `outer` + and cmp_pos(outer.start_row, outer.start_col, inner_inclusive_end_row, inner_inclusive_end_col) == -1 + and cmp_pos( + outer_inclusive_end_row, + outer_inclusive_end_col, + inner.start_row, + inner.start_col + ) + == 1 end --- Computes the common range shared by the given ranges. @@ -128,12 +237,21 @@ end ---@return vim.Range? range that is present inside both `r1` and `r2`. --- `nil` if such range does not exist. function Range.intersect(r1, r2) - if r1.end_ <= r2.start or r1.start >= r2.end_ then + local r1_inclusive_end_row, r1_inclusive_end_col = + to_inclusive_pos(r1.end_row, r1.end_col, r1.buf) + local r2_inclusive_end_row, r2_inclusive_end_col = + to_inclusive_pos(r2.end_row, r2.end_col, r2.buf) + + if + cmp_pos(r1_inclusive_end_row, r1_inclusive_end_col, r2.start_row, r2.start_col) ~= 1 + or cmp_pos(r1.start_row, r1.start_col, r2_inclusive_end_row, r2_inclusive_end_col) ~= -1 + then return nil end - local rs = r1.start <= r2.start and r2 or r1 - local re = r1.end_ >= r2.end_ and r2 or r1 - return Range.new(rs.start, re.end_) + + local rs = cmp_pos(r1.start_row, r1.start_col, r2.start_row, r2.start_col) ~= 1 and r2 or r1 + local re = cmp_pos(r1.end_row, r1.end_col, r2.end_row, r2.end_col) ~= -1 and r2 or r1 + return Range.new(rs.start_row, rs.start_col, re.end_row, re.end_col) end --- Converts |vim.Range| to `lsp.Range`. @@ -156,8 +274,10 @@ function Range.to_lsp(range, position_encoding) ---@type lsp.Range return { - ['start'] = range.start:to_lsp(position_encoding), - ['end'] = range.end_:to_lsp(position_encoding), + ['start'] = vim + .pos(range.start_row, range.start_col, { buf = range.buf }) + :to_lsp(position_encoding), + ['end'] = vim.pos(range.end_row, range.end_col, { buf = range.buf }):to_lsp(position_encoding), } end @@ -190,6 +310,97 @@ function Range.lsp(buf, range, position_encoding) return Range.new(start, end_) end +--- Converts |vim.Range| to extmark range (see |api-indexing|). +--- +--- Example: +--- ```lua +--- -- `buf` is required for conversion to extmark range. +--- local buf = vim.api.nvim_get_current_buf() +--- local range = vim.range(3, 5, 4, 0, { buf = buf }) +--- +--- -- Convert to extmark range, you can call it in a method style. +--- local extmark_range = range:to_extmark() +--- ``` +---@param range vim.Range +function Range.to_extmark(range) + validate('range', range, 'table') + + local srow, scol = vim.pos(range.start_row, range.start_col, { buf = range.buf }):to_extmark() + local erow, ecol = vim.pos(range.end_row, range.end_col, { buf = range.buf }):to_extmark() + return srow, scol, erow, ecol +end + +--- Creates a new |vim.Range| from extmark range (see |api-indexing|). +--- +--- Example: +--- ```lua +--- local buf = vim.api.nvim_get_current_buf() +--- +--- local range = vim.range.extmark(3, 5, 4, 0, { buf = buf }) +--- ``` +---@param start_row integer +---@param start_col integer +---@param end_row integer +---@param end_col integer +---@param opts vim.Pos.Optional|nil +function Range.extmark(start_row, start_col, end_row, end_col, opts) + validate('range', start_row, 'number') + validate('range', start_col, 'number') + validate('range', end_row, 'number') + validate('range', end_col, 'number') + + local start = vim.pos.extmark(start_row, start_col, opts) + local end_ = vim.pos.extmark(end_row, end_col, opts) + + return Range.new(start, end_) +end + +--- Converts |vim.Range| to mark-like range (see |api-indexing|). +--- +--- Example: +--- ```lua +--- -- `buf` is required for conversion to extmark range. +--- local buf = vim.api.nvim_get_current_buf() +--- local range = vim.range(3, 5, 4, 0, { buf = buf }) +--- +--- -- Convert to cursor range, you can call it in a method style. +--- local cursor_range = range:to_cursor() +--- ``` +---@param range vim.Range +function Range.to_cursor(range) + validate('range', range, 'table') + + local srow, scol = vim.pos(range.start_row, range.start_col, { buf = range.buf }):to_cursor() + local erow, ecol = vim.pos(range.end_row, range.end_col, { buf = range.buf }):to_cursor() + return srow, scol, erow, ecol +end + +--- Creates a new |vim.Range| from mark-like range (see |api-indexing|). +--- +--- Example: +--- ```lua +--- local buf = vim.api.nvim_get_current_buf() +--- local start = vim.api.nvim_win_get_cursor(0) +--- -- move the cursor +--- local end_ = vim.api.nvim_win_get_cursor(0) +--- +--- local range = vim.range.cursor(start, end_, { buf = buf }) +--- ``` +---@param buf integer +---@param start_pos [integer, integer] +---@param end_pos [integer, integer] +---@param opts vim.Pos.Optional|nil +function Range.cursor(buf, start_pos, end_pos, opts) + validate('buf', buf, 'number') + validate('range', start_pos, 'table') + validate('range', end_pos, 'table') + + local start = vim.pos.cursor(start_pos, opts) + local end_ = vim.pos.cursor(end_pos, opts) + + return Range.new(start, end_) +end + -- Overload `Range.new` to allow calling this module as a function. setmetatable(Range, { __call = function(_, ...) diff --git a/test/functional/lua/pos_spec.lua b/test/functional/lua/pos_spec.lua index 4102c8f536..3f7b9fffbf 100644 --- a/test/functional/lua/pos_spec.lua +++ b/test/functional/lua/pos_spec.lua @@ -14,9 +14,9 @@ describe('vim.pos', function() local pos = exec_lua(function() return vim.pos(3, 5) end) - eq(3, pos.row) - eq(5, pos.col) - eq(nil, pos.buf) + eq(3, pos[1]) + eq(5, pos[2]) + eq(nil, pos[3]) local buf = exec_lua(function() return vim.api.nvim_create_buf(false, true) @@ -24,9 +24,9 @@ describe('vim.pos', function() pos = exec_lua(function() return vim.pos(3, 5, { buf = buf }) end) - eq(3, pos.row) - eq(5, pos.col) - eq(buf, pos.buf) + eq(3, pos[1]) + eq(5, pos[2]) + eq(buf, pos[3]) end) it('comparisons by overloaded operators', function() @@ -82,9 +82,39 @@ describe('vim.pos', function() return vim.pos.lsp(buf, lsp_pos, 'utf-16') end) eq({ - buf = buf, - row = 0, - col = 36, + 0, + 36, + buf, }, pos) end) + + it("converts between vim.Pos and extmark on buffer's last line", function() + local buf = exec_lua(function() + return vim.api.nvim_get_current_buf() + end) + insert('Some text') + local extmark_pos = { + exec_lua(function() + local pos = vim.pos(1, 0, { buf = buf }) + return pos:to_extmark() + end), + } + eq({ 0, 9 }, extmark_pos) + local pos = exec_lua(function() + return vim.pos.extmark(extmark_pos[1], extmark_pos[2], { buf = buf }) + end) + eq({ 0, 9, buf }, pos) + + local extmark_pos2 = { + exec_lua(function() + local pos2 = vim.pos(0, 9, { buf = buf }) + return pos2:to_extmark() + end), + } + eq({ 0, 9 }, extmark_pos2) + local pos2 = exec_lua(function() + return vim.pos.extmark(extmark_pos2[1], extmark_pos2[2], { buf = buf }) + end) + eq({ 0, 9, buf }, pos2) + end) end) diff --git a/test/functional/lua/range_spec.lua b/test/functional/lua/range_spec.lua index 58f10bb15a..580e7813b1 100644 --- a/test/functional/lua/range_spec.lua +++ b/test/functional/lua/range_spec.lua @@ -14,32 +14,29 @@ describe('vim.range', function() local range = exec_lua(function() return vim.range(3, 5, 4, 6) end) - eq(3, range.start.row) - eq(5, range.start.col) - eq(4, range.end_.row) - eq(6, range.end_.col) - eq(nil, range.start.buf) - eq(nil, range.end_.buf) + eq(3, range[1]) + eq(5, range[2]) + eq(4, range[3]) + eq(6, range[4]) + eq(nil, range[5]) local buf = exec_lua(function() return vim.api.nvim_create_buf(false, true) end) range = exec_lua(function() return vim.range(3, 5, 4, 6, { buf = buf }) end) - eq(buf, range.start.buf) - eq(buf, range.end_.buf) + eq(buf, range[5]) end) it('creates a range from two positions when optional fields are not matched', function() local range = exec_lua(function() return vim.range(vim.pos(3, 5), vim.pos(4, 6)) end) - eq(3, range.start.row) - eq(5, range.start.col) - eq(4, range.end_.row) - eq(6, range.end_.col) - eq(nil, range.start.buf) - eq(nil, range.end_.buf) + eq(3, range[1]) + eq(5, range[2]) + eq(4, range[3]) + eq(6, range[4]) + eq(nil, range[5]) local buf1 = exec_lua(function() return vim.api.nvim_create_buf(false, true) @@ -47,8 +44,7 @@ describe('vim.range', function() range = exec_lua(function() return vim.range(vim.pos(3, 5, { buf = buf1 }), vim.pos(4, 6, { buf = buf1 })) end) - eq(buf1, range.start.buf) - eq(buf1, range.end_.buf) + eq(buf1, range[5]) local buf2 = exec_lua(function() return vim.api.nvim_create_buf(false, true) @@ -78,8 +74,11 @@ describe('vim.range', function() return vim.range.lsp(buf, lsp_range, 'utf-16') end) eq({ - start = { row = 0, col = 10, buf = buf }, - end_ = { row = 0, col = 36, buf = buf }, + 0, + 10, + 0, + 36, + buf, }, range) end) @@ -91,4 +90,13 @@ describe('vim.range', function() end) ) end) + + it('checks whether a range does not contain an empty range just outside it', function() + eq( + false, + exec_lua(function() + return vim.range(0, 0, 0, 4):has(vim.range(0, 0, 0, 0)) + end) + ) + end) end) diff --git a/test/functional/plugin/lsp/inline_completion_spec.lua b/test/functional/plugin/lsp/inline_completion_spec.lua index d82410153f..a5ecf5fdd5 100644 --- a/test/functional/plugin/lsp/inline_completion_spec.lua +++ b/test/functional/plugin/lsp/inline_completion_spec.lua @@ -271,16 +271,11 @@ describe('vim.lsp.inline_completion', function() return b; }]]), range = { - end_ = { - buf = 1, - col = 20, - row = 0, - }, - start = { - buf = 1, - col = 0, - row = 0, - }, + 0, + 0, + 0, + 20, + 1, }, }, result) end)