mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2026-05-23 21:30:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

revert: "docs: vim.range, vim.pos #38869"

Browse Source 
This reverts commit c530fd8e75.
This commit is contained in:
Yi Ming
2026-04-15 20:46:46 +08:00
parent 202e17deef
commit 481e70550c
3 changed files with 207 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

253
runtime/doc/lua.txt
View File

@@ -4290,53 +4290,28 @@ by |vim.Pos| objects.
• {row} (`integer`) 0-based byte index.
• {col} (`integer`) 0-based byte index.
• {buf} (`integer`) buffer handle.
• {to_lsp} (`fun(self: vim.Pos, position_encoding: lsp.PositionEncodingKind)`)
• {to_lsp} (`fun(pos: vim.Pos, position_encoding: lsp.PositionEncodingKind)`)
See |Pos:to_lsp()|.
• {to_cursor} (`fun(self: vim.Pos): integer, integer`) See
• {lsp} (`fun(buf: integer, pos: lsp.Position, position_encoding: lsp.PositionEncodingKind)`)
See |Pos:lsp()|.
• {to_cursor} (`fun(pos: vim.Pos): integer, integer`) See
|Pos:to_cursor()|.
• {to_extmark} (`fun(self: vim.Pos): integer, integer`) See
• {cursor} (`fun(buf: integer, pos: [integer, integer])`) See
|Pos:cursor()|.
• {to_extmark} (`fun(pos: vim.Pos): integer, integer`) See
|Pos:to_extmark()|.
• {extmark} (`fun(buf: integer, row: integer, col: integer)`) See
|Pos:extmark()|.
Pos:to_cursor() *Pos:to_cursor()*
Converts |vim.Pos| to cursor position (see |api-indexing|).
Return (multiple): ~
(`integer`)
(`integer`)
Pos:to_extmark() *Pos:to_extmark()*
Converts |vim.Pos| to extmark position (see |api-indexing|).
Return (multiple): ~
(`integer`)
(`integer`)
Pos:to_lsp({position_encoding}) *Pos:to_lsp()*
Converts |vim.Pos| to `lsp.Position`.
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local pos = vim.pos(buf, 3, 5)
-- Convert to LSP position, you can call it in a method style.
local lsp_pos = pos:to_lsp('utf-16')
<
Parameters: ~
• {position_encoding} (`lsp.PositionEncodingKind`)
vim.pos.cursor({buf}, {pos}) *vim.pos.cursor()*
Pos:cursor({buf}, {pos}) *Pos:cursor()*
Creates a new |vim.Pos| from cursor position (see |api-indexing|).
Parameters: ~
• {buf} (`integer`)
• {pos} (`[integer, integer]`)
Return: ~
(`vim.Pos`) See |vim.Pos|.
vim.pos.extmark({buf}, {row}, {col}) *vim.pos.extmark()*
Pos:extmark({buf}, {row}, {col}) *Pos:extmark()*
Creates a new |vim.Pos| from extmark position (see |api-indexing|).
Parameters: ~
@@ -4344,10 +4319,7 @@ vim.pos.extmark({buf}, {row}, {col}) *vim.pos.extmark()*
• {row} (`integer`)
• {col} (`integer`)
Return: ~
(`vim.Pos`) See |vim.Pos|.
vim.pos.lsp({buf}, {pos}, {position_encoding}) *vim.pos.lsp()*
Pos:lsp({buf}, {pos}, {position_encoding}) *Pos:lsp()*
Creates a new |vim.Pos| from `lsp.Position`.
Example: >lua
@@ -4365,8 +4337,40 @@ vim.pos.lsp({buf}, {pos}, {position_encoding}) *vim.pos.lsp()*
• {pos} (`lsp.Position`)
• {position_encoding} (`lsp.PositionEncodingKind`)
Return: ~
(`vim.Pos`) See |vim.Pos|.
Pos:to_cursor({pos}) *Pos:to_cursor()*
Converts |vim.Pos| to cursor position (see |api-indexing|).
Parameters: ~
• {pos} (`vim.Pos`) See |vim.Pos|.
Return (multiple): ~
(`integer`)
(`integer`)
Pos:to_extmark({pos}) *Pos:to_extmark()*
Converts |vim.Pos| to extmark position (see |api-indexing|).
Parameters: ~
• {pos} (`vim.Pos`) See |vim.Pos|.
Return (multiple): ~
(`integer`)
(`integer`)
Pos:to_lsp({pos}, {position_encoding}) *Pos:to_lsp()*
Converts |vim.Pos| to `lsp.Position`.
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local pos = vim.pos(buf, 3, 5)
-- Convert to LSP position, you can call it in a method style.
local lsp_pos = pos:to_lsp('utf-16')
<
Parameters: ~
• {pos} (`vim.Pos`) See |vim.Pos|.
• {position_encoding} (`lsp.PositionEncodingKind`)
==============================================================================
@@ -4416,81 +4420,23 @@ Provides operations to compare, calculate, and convert ranges represented by
• {buf} (`integer`) Optional buffer handle.
• {is_empty} (`fun(self: vim.Range): boolean`) See
|Range:is_empty()|.
• {has} (`fun(self: vim.Range, inner: vim.Range|vim.Pos): boolean`)
• {has} (`fun(outer: vim.Range, inner: vim.Range|vim.Pos): boolean`)
See |Range:has()|.
• {intersect} (`fun(self: vim.Range, r2: vim.Range): vim.Range?`) See
• {intersect} (`fun(r1: vim.Range, r2: vim.Range): vim.Range?`) See
|Range:intersect()|.
• {to_lsp} (`fun(self: vim.Range, position_encoding: lsp.PositionEncodingKind): lsp.Range`)
• {to_lsp} (`fun(range: vim.Range, position_encoding: lsp.PositionEncodingKind): lsp.Range`)
See |Range:to_lsp()|.
• {to_extmark} (`fun(self: vim.Range)`) See |Range:to_extmark()|.
• {to_cursor} (`fun(self: vim.Range)`) See |Range:to_cursor()|.
• {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(buf: integer, start_row: integer, start_col: integer, end_row: integer, end_col: integer)`)
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])`)
See |Range:cursor()|.
Range:has({inner}) *Range:has()*
Checks whether range contains {inner} range or position.
Parameters: ~
• {inner} (`vim.Range|vim.Pos`)
Return: ~
(`boolean`) `true` if range fully contains {inner} range or position.
Range:intersect({r2}) *Range:intersect()*
Computes the common range shared by range and {r2}
Parameters: ~
• {r2} (`vim.Range`) Second range to intersect. See |vim.Range|.
Return: ~
(`vim.Range?`) range that is present inside both range and `r2`. `nil`
if such range does not exist. See |vim.Range|.
Range:is_empty() *Range:is_empty()*
Checks whether the given range is empty; i.e., start >= end.
Return: ~
(`boolean`) `true` if the given range is empty
Range:to_cursor() *Range:to_cursor()*
Converts |vim.Range| to mark-like range (see |api-indexing|).
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- Convert to cursor range, you can call it in a method style.
local cursor_range = range:to_cursor()
<
Range:to_extmark() *Range:to_extmark()*
Converts |vim.Range| to extmark range (see |api-indexing|).
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- Convert to extmark range, you can call it in a method style.
local extmark_range = range:to_extmark()
<
Range:to_lsp({position_encoding}) *Range:to_lsp()*
Converts |vim.Range| to `lsp.Range`.
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- Convert to LSP range, you can call it in a method style.
local lsp_range = range:to_lsp('utf-16')
<
Parameters: ~
• {position_encoding} (`lsp.PositionEncodingKind`)
Return: ~
(`lsp.Range`)
vim.range.cursor({buf}, {start_pos}, {end_pos}) *vim.range.cursor()*
Range:cursor({buf}, {start_pos}, {end_pos}) *Range:cursor()*
Creates a new |vim.Range| from mark-like range (see |api-indexing|).
Example: >lua
@@ -4507,11 +4453,8 @@ vim.range.cursor({buf}, {start_pos}, {end_pos}) *vim.range.cursor()*
• {start_pos} (`[integer, integer]`)
• {end_pos} (`[integer, integer]`)
Return: ~
(`vim.Range`) See |vim.Range|.
*vim.range.extmark()*
vim.range.extmark({buf}, {start_row}, {start_col}, {end_row}, {end_col})
*Range:extmark()*
Range:extmark({buf}, {start_row}, {start_col}, {end_row}, {end_col})
Creates a new |vim.Range| from extmark range (see |api-indexing|).
Example: >lua
@@ -4527,10 +4470,35 @@ vim.range.extmark({buf}, {start_row}, {start_col}, {end_row}, {end_col})
• {end_row} (`integer`)
• {end_col} (`integer`)
Return: ~
(`vim.Range`) See |vim.Range|.
Range:has({outer}, {inner}) *Range:has()*
Checks whether {outer} range contains {inner} range or position.
vim.range.lsp({buf}, {range}, {position_encoding}) *vim.range.lsp()*
Parameters: ~
• {outer} (`vim.Range`) See |vim.Range|.
• {inner} (`vim.Range|vim.Pos`)
Return: ~
(`boolean`) `true` if {outer} range fully contains {inner} range or
position.
Range:intersect({r1}, {r2}) *Range:intersect()*
Computes the common range shared by the given ranges.
Parameters: ~
• {r1} (`vim.Range`) First range to intersect. See |vim.Range|.
• {r2} (`vim.Range`) Second range to intersect. See |vim.Range|.
Return: ~
(`vim.Range?`) range that is present inside both `r1` and `r2`. `nil`
if such range does not exist. See |vim.Range|.
Range:is_empty() *Range:is_empty()*
Checks whether the given range is empty; i.e., start >= end.
Return: ~
(`boolean`) `true` if the given range is empty
Range:lsp({buf}, {range}, {position_encoding}) *Range:lsp()*
Creates a new |vim.Range| from `lsp.Range`.
Example: >lua
@@ -4548,8 +4516,51 @@ vim.range.lsp({buf}, {range}, {position_encoding}) *vim.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
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- 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
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- 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`.
Example: >lua
local buf = vim.api.nvim_get_current_buf()
local range = vim.range(buf, 3, 5, 4, 0)
-- Convert to LSP range, you can call it in a method style.
local lsp_range = range:to_lsp('utf-16')
<
Parameters: ~
• {range} (`vim.Range`) See |vim.Range|.
• {position_encoding} (`lsp.PositionEncodingKind`)
Return: ~
(`vim.Range`) See |vim.Range|.
(`lsp.Range`)
==============================================================================

48
runtime/lua/vim/pos.lua
View File

@@ -6,8 +6,6 @@
--- Provides operations to compare, calculate, and convert positions represented by |vim.Pos|
--- objects.
local M = {}
local api = vim.api
local validate = vim.validate
@@ -43,8 +41,7 @@ local validate = vim.validate
---@field private [3] integer underlying representation of buf
local Pos = {}
M._Pos = Pos
---@private
---@param pos vim.Pos
---@param key any
function Pos.__index(pos, key)
@@ -100,14 +97,17 @@ local function cmp_pos(p1, p2)
return -1
end
---@private
function Pos.__lt(...)
return cmp_pos(...) == -1
end
---@private
function Pos.__le(...)
return cmp_pos(...) ~= 1
end
---@private
function Pos.__eq(...)
return cmp_pos(...) == 0
end
@@ -129,11 +129,13 @@ end
--- -- Convert to LSP position, you can call it in a method style.
--- local lsp_pos = pos:to_lsp('utf-16')
--- ```
---@param pos vim.Pos
---@param position_encoding lsp.PositionEncodingKind
function Pos:to_lsp(position_encoding)
function Pos.to_lsp(pos, position_encoding)
validate('pos', pos, 'table')
validate('position_encoding', position_encoding, 'string')
local buf, row, col = self.buf, self.row, self.col
local buf, row, col = pos.buf, pos.row, pos.col
-- When on the first character,
-- we can ignore the difference between byte and character.
if col > 0 then
@@ -159,8 +161,7 @@ end
---@param buf integer
---@param pos lsp.Position
---@param position_encoding lsp.PositionEncodingKind
---@return vim.Pos
function M.lsp(buf, pos, position_encoding)
function Pos.lsp(buf, pos, position_encoding)
validate('buf', buf, 'number')
validate('pos', pos, 'table')
validate('position_encoding', position_encoding, 'string')
@@ -178,29 +179,30 @@ function M.lsp(buf, pos, position_encoding)
end
--- Converts |vim.Pos| to cursor position (see |api-indexing|).
---@param pos vim.Pos
---@return integer, integer
function Pos:to_cursor()
return self.row + 1, self.col
function Pos.to_cursor(pos)
return pos.row + 1, pos.col
end
--- Creates a new |vim.Pos| from cursor position (see |api-indexing|).
---@param buf integer
---@param pos [integer, integer]
---@return vim.Pos
function M.cursor(buf, pos)
function Pos.cursor(buf, pos)
return Pos.new(buf, pos[1] - 1, pos[2])
end
--- Converts |vim.Pos| to extmark position (see |api-indexing|).
---@param pos vim.Pos
---@return integer, integer
function Pos:to_extmark()
local line_num = #api.nvim_buf_get_lines(self.buf, 0, -1, true)
function Pos.to_extmark(pos)
local line_count = api.nvim_buf_line_count(pos.buf)
local row = self.row
local col = self.col
if self.col == 0 and self.row == line_num then
local row = pos.row
local col = pos.col
if pos.col == 0 and pos.row == line_count then
row = row - 1
col = #get_line(self.buf, row)
col = #get_line(pos.buf, row)
end
return row, col
@@ -210,16 +212,16 @@ end
---@param buf integer
---@param row integer
---@param col integer
---@return vim.Pos
function M.extmark(buf, row, col)
function Pos.extmark(buf, row, col)
return Pos.new(buf, row, col)
end
setmetatable(M, {
-- Overload `Range.new` to allow calling this module as a function.
setmetatable(Pos, {
__call = function(_, ...)
return Pos.new(...)
end,
})
---@cast M +fun(buf: integer, row: integer, col: integer): vim.Pos
---@cast Pos +fun(buf: integer, row: integer, col: integer): vim.Pos
return M
return Pos

90
runtime/lua/vim/range.lua
View File

@@ -6,8 +6,6 @@
--- Provides operations to compare, calculate, and convert ranges represented by |vim.Range|
--- objects.
local M = {}
local validate = vim.validate
local api = vim.api
@@ -51,6 +49,7 @@ local api = vim.api
---@field private [5] integer underlying representation of buf
local Range = {}
---@private
---@param pos vim.Range
---@param key any
function Range.__index(pos, key)
@@ -153,6 +152,7 @@ local function to_inclusive_pos(buf, row, col)
return row, col
end
---@private
---@param r1 vim.Range
---@param r2 vim.Range
function Range.__lt(r1, r2)
@@ -161,6 +161,7 @@ function Range.__lt(r1, r2)
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)
@@ -169,6 +170,7 @@ function Range.__le(r1, r2)
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)
@@ -186,28 +188,29 @@ function Range:is_empty()
return cmp_pos(self.start_row, self.start_col, inclusive_end_row, inclusive_end_col) ~= -1
end
--- Checks whether range contains {inner} range or position.
--- Checks whether {outer} range contains {inner} range or position.
---
---@param outer vim.Range
---@param inner vim.Range|vim.Pos
---@return boolean `true` if range fully contains {inner} range or position.
function Range:has(inner)
if getmetatable(inner) == vim.pos._Pos then
---@return boolean `true` if {outer} range fully contains {inner} range or position.
function Range.has(outer, inner)
if getmetatable(inner) == vim.pos then
---@cast inner -vim.Range
return cmp_pos(self.start_row, self.start_col, inner.row, inner.col) ~= 1
and cmp_pos(self.end_row, self.end_col, inner.row, inner.col) ~= -1
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(self.buf, self.end_row, self.end_col)
to_inclusive_pos(outer.buf, outer.end_row, outer.end_col)
local inner_inclusive_end_row, inner_inclusive_end_col =
to_inclusive_pos(inner.buf, inner.end_row, inner.end_col)
return cmp_pos(self.start_row, self.start_col, inner.start_row, inner.start_col) ~= 1
and cmp_pos(self.end_row, self.end_col, inner.end_row, inner.end_col) ~= -1
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(self.start_row, self.start_col, inner_inclusive_end_row, inner_inclusive_end_col) == -1
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,
@@ -217,31 +220,32 @@ function Range:has(inner)
== 1
end
--- Computes the common range shared by range and {r2}
--- Computes the common range shared by the given ranges.
---
---@param r1 vim.Range First range to intersect.
---@param r2 vim.Range Second range to intersect
---@return vim.Range? range that is present inside both range and `r2`.
---@return vim.Range? range that is present inside both `r1` and `r2`.
--- `nil` if such range does not exist.
function Range:intersect(r2)
if self.buf ~= r2.buf then
function Range.intersect(r1, r2)
if r1.buf ~= r2.buf then
return nil
end
local r1_inclusive_end_row, r1_inclusive_end_col =
to_inclusive_pos(self.buf, self.end_row, self.end_col)
to_inclusive_pos(r1.buf, r1.end_row, r1.end_col)
local r2_inclusive_end_row, r2_inclusive_end_col =
to_inclusive_pos(r2.buf, r2.end_row, r2.end_col)
if
cmp_pos(r1_inclusive_end_row, r1_inclusive_end_col, r2.start_row, r2.start_col) ~= 1
or cmp_pos(self.start_row, self.start_col, r2_inclusive_end_row, r2_inclusive_end_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 = cmp_pos(self.start_row, self.start_col, r2.start_row, r2.start_col) ~= 1 and r2 or self
local re = cmp_pos(self.end_row, self.end_col, r2.end_row, r2.end_col) ~= -1 and r2 or self
return Range.new(self.buf, rs.start_row, rs.start_col, re.end_row, re.end_col)
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(r1.buf, rs.start_row, rs.start_col, re.end_row, re.end_col)
end
--- Converts |vim.Range| to `lsp.Range`.
@@ -254,15 +258,17 @@ end
--- -- Convert to LSP range, you can call it in a method style.
--- local lsp_range = range:to_lsp('utf-16')
--- ```
---@param range vim.Range
---@param position_encoding lsp.PositionEncodingKind
---@return lsp.Range
function Range:to_lsp(position_encoding)
function Range.to_lsp(range, position_encoding)
validate('range', range, 'table')
validate('position_encoding', position_encoding, 'string', true)
---@type lsp.Range
return {
['start'] = vim.pos(self.buf, self.start_row, self.start_col):to_lsp(position_encoding),
['end'] = vim.pos(self.buf, self.end_row, self.end_col):to_lsp(position_encoding),
['start'] = vim.pos(range.buf, range.start_row, range.start_col):to_lsp(position_encoding),
['end'] = vim.pos(range.buf, range.end_row, range.end_col):to_lsp(position_encoding),
}
end
@@ -281,8 +287,7 @@ end
---@param buf integer
---@param range lsp.Range
---@param position_encoding lsp.PositionEncodingKind
---@return vim.Range
function M.lsp(buf, range, position_encoding)
function Range.lsp(buf, range, position_encoding)
validate('buf', buf, 'number')
validate('range', range, 'table')
validate('position_encoding', position_encoding, 'string')
@@ -305,9 +310,12 @@ end
--- -- Convert to extmark range, you can call it in a method style.
--- local extmark_range = range:to_extmark()
--- ```
function Range:to_extmark()
local srow, scol = vim.pos(self.buf, self.start_row, self.start_col):to_extmark()
local erow, ecol = vim.pos(self.buf, self.end_row, self.end_col):to_extmark()
---@param range vim.Range
function Range.to_extmark(range)
validate('range', range, 'table')
local srow, scol = vim.pos(range.buf, range.start_row, range.start_col):to_extmark()
local erow, ecol = vim.pos(range.buf, range.end_row, range.end_col):to_extmark()
return srow, scol, erow, ecol
end
@@ -324,8 +332,7 @@ end
---@param start_col integer
---@param end_row integer
---@param end_col integer
---@return vim.Range
function M.extmark(buf, start_row, start_col, end_row, end_col)
function Range.extmark(buf, start_row, start_col, end_row, end_col)
validate('buf', buf, 'number')
validate('start_row', start_row, 'number')
validate('start_col', start_col, 'number')
@@ -348,9 +355,12 @@ end
--- -- Convert to cursor range, you can call it in a method style.
--- local cursor_range = range:to_cursor()
--- ```
function Range:to_cursor()
local srow, scol = vim.pos(self.buf, self.start_row, self.start_col):to_cursor()
local erow, ecol = vim.pos(self.buf, self.end_row, self.end_col):to_cursor()
---@param range vim.Range
function Range.to_cursor(range)
validate('range', range, 'table')
local srow, scol = vim.pos(range.buf, range.start_row, range.start_col):to_cursor()
local erow, ecol = vim.pos(range.buf, range.end_row, range.end_col):to_cursor()
return srow, scol, erow, ecol
end
@@ -368,8 +378,7 @@ end
---@param buf integer
---@param start_pos [integer, integer]
---@param end_pos [integer, integer]
---@return vim.Range
function M.cursor(buf, start_pos, end_pos)
function Range.cursor(buf, start_pos, end_pos)
validate('buf', buf, 'number')
validate('range', start_pos, 'table')
validate('range', end_pos, 'table')
@@ -380,12 +389,13 @@ function M.cursor(buf, start_pos, end_pos)
return Range.new(start, end_)
end
setmetatable(M, {
-- Overload `Range.new` to allow calling this module as a function.
setmetatable(Range, {
__call = function(_, ...)
return Range.new(...)
end,
})
---@cast M +fun(start: vim.Pos, end_: vim.Pos): vim.Range
---@cast M +fun(buf: integer, start_row: integer, start_col: integer, end_row: integer, end_col: integer): vim.Range
---@cast Range +fun(start: vim.Pos, end_: vim.Pos): vim.Range
---@cast Range +fun(buf: integer, start_row: integer, start_col: integer, end_row: integer, end_col: integer): vim.Range
return M
return Range