Merge pull request #24363 from lewis6991/docs/luatypes

docs(lua): move some function docs to lua files

13 files changed, 1417 insertions, 598 deletions

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 47215416e0..bb0aa97a0d 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -1094,7 +1094,7 @@ function vim._init_defaults()
   vim._init_default_autocmds()
 end
 
-require('vim._meta')
+require('vim._options')
 
 -- Remove at Nvim 1.0
 ---@deprecated
diff --git a/runtime/lua/vim/_meta.lua b/runtime/lua/vim/_meta.lua
deleted file mode 100644
index 41e6e8be86..0000000000
--- a/runtime/lua/vim/_meta.lua
+++ /dev/null
@@ -1,575 +0,0 @@
-local api = vim.api
-
--- TODO(tjdevries): Improve option metadata so that this doesn't have to be hardcoded.
---                  Can be done in a separate PR.
-local key_value_options = {
-  fillchars = true,
-  fcs = true,
-  listchars = true,
-  lcs = true,
-  winhighlight = true,
-  winhl = true,
-}
-
---- Convert a vimoption_T style dictionary to the correct OptionType associated with it.
----@return string
-local function get_option_metatype(name, info)
-  if info.type == 'string' then
-    if info.flaglist then
-      return 'set'
-    elseif info.commalist then
-      if key_value_options[name] then
-        return 'map'
-      end
-      return 'array'
-    end
-    return 'string'
-  end
-  return info.type
-end
-
-local options_info = setmetatable({}, {
-  __index = function(t, k)
-    local info = api.nvim_get_option_info(k)
-    info.metatype = get_option_metatype(k, info)
-    rawset(t, k, info)
-    return rawget(t, k)
-  end,
-})
-
-vim.env = setmetatable({}, {
-  __index = function(_, k)
-    local v = vim.fn.getenv(k)
-    if v == vim.NIL then
-      return nil
-    end
-    return v
-  end,
-
-  __newindex = function(_, k, v)
-    vim.fn.setenv(k, v)
-  end,
-})
-
-local function opt_validate(option_name, target_scope)
-  local scope = options_info[option_name].scope
-  if scope ~= target_scope then
-    local scope_to_string = { buf = 'buffer', win = 'window' }
-    error(
-      string.format(
-        [['%s' is a %s option, not a %s option. See ":help %s"]],
-        option_name,
-        scope_to_string[scope] or scope,
-        scope_to_string[target_scope] or target_scope,
-        option_name
-      )
-    )
-  end
-end
-
-local function new_buf_opt_accessor(bufnr)
-  return setmetatable({}, {
-    __index = function(_, k)
-      if bufnr == nil and type(k) == 'number' then
-        return new_buf_opt_accessor(k)
-      end
-      opt_validate(k, 'buf')
-      return api.nvim_get_option_value(k, { buf = bufnr or 0 })
-    end,
-
-    __newindex = function(_, k, v)
-      opt_validate(k, 'buf')
-      return api.nvim_set_option_value(k, v, { buf = bufnr or 0 })
-    end,
-  })
-end
-
-vim.bo = new_buf_opt_accessor()
-
-local function new_win_opt_accessor(winid, bufnr)
-  return setmetatable({}, {
-    __index = function(_, k)
-      if bufnr == nil and type(k) == 'number' then
-        if winid == nil then
-          return new_win_opt_accessor(k)
-        else
-          return new_win_opt_accessor(winid, k)
-        end
-      end
-
-      if bufnr ~= nil and bufnr ~= 0 then
-        error('only bufnr=0 is supported')
-      end
-
-      opt_validate(k, 'win')
-      -- TODO(lewis6991): allow passing both buf and win to nvim_get_option_value
-      return api.nvim_get_option_value(k, {
-        scope = bufnr and 'local' or nil,
-        win = winid or 0,
-      })
-    end,
-
-    __newindex = function(_, k, v)
-      opt_validate(k, 'win')
-      -- TODO(lewis6991): allow passing both buf and win to nvim_set_option_value
-      return api.nvim_set_option_value(k, v, {
-        scope = bufnr and 'local' or nil,
-        win = winid or 0,
-      })
-    end,
-  })
-end
-
-vim.wo = new_win_opt_accessor()
-
--- vim global option
---  this ONLY sets the global option. like `setglobal`
-vim.go = setmetatable({}, {
-  __index = function(_, k)
-    return api.nvim_get_option_value(k, { scope = 'global' })
-  end,
-  __newindex = function(_, k, v)
-    return api.nvim_set_option_value(k, v, { scope = 'global' })
-  end,
-})
-
--- vim `set` style options.
---  it has no additional metamethod magic.
-vim.o = setmetatable({}, {
-  __index = function(_, k)
-    return api.nvim_get_option_value(k, {})
-  end,
-  __newindex = function(_, k, v)
-    return api.nvim_set_option_value(k, v, {})
-  end,
-})
-
----@brief [[
---- vim.opt, vim.opt_local and vim.opt_global implementation
----
---- To be used as helpers for working with options within neovim.
---- For information on how to use, see :help vim.opt
----
----@brief ]]
-
---- Preserves the order and does not mutate the original list
-local function remove_duplicate_values(t)
-  local result, seen = {}, {}
-  for _, v in ipairs(t) do
-    if not seen[v] then
-      table.insert(result, v)
-    end
-
-    seen[v] = true
-  end
-
-  return result
-end
-
--- Check whether the OptionTypes is allowed for vim.opt
--- If it does not match, throw an error which indicates which option causes the error.
-local function assert_valid_value(name, value, types)
-  local type_of_value = type(value)
-  for _, valid_type in ipairs(types) do
-    if valid_type == type_of_value then
-      return
-    end
-  end
-
-  error(
-    string.format(
-      "Invalid option type '%s' for '%s', should be %s",
-      type_of_value,
-      name,
-      table.concat(types, ' or ')
-    )
-  )
-end
-
-local function passthrough(_, x)
-  return x
-end
-
-local function tbl_merge(left, right)
-  return vim.tbl_extend('force', left, right)
-end
-
-local function tbl_remove(t, value)
-  if type(value) == 'string' then
-    t[value] = nil
-  else
-    for _, v in ipairs(value) do
-      t[v] = nil
-    end
-  end
-
-  return t
-end
-
-local valid_types = {
-  boolean = { 'boolean' },
-  number = { 'number' },
-  string = { 'string' },
-  set = { 'string', 'table' },
-  array = { 'string', 'table' },
-  map = { 'string', 'table' },
-}
-
--- Map of functions to take a Lua style value and convert to vimoption_T style value.
--- Each function takes (info, lua_value) -> vim_value
-local to_vim_value = {
-  boolean = passthrough,
-  number = passthrough,
-  string = passthrough,
-
-  set = function(info, value)
-    if type(value) == 'string' then
-      return value
-    end
-
-    if info.flaglist and info.commalist then
-      local keys = {}
-      for k, v in pairs(value) do
-        if v then
-          table.insert(keys, k)
-        end
-      end
-
-      table.sort(keys)
-      return table.concat(keys, ',')
-    else
-      local result = ''
-      for k, v in pairs(value) do
-        if v then
-          result = result .. k
-        end
-      end
-
-      return result
-    end
-  end,
-
-  array = function(info, value)
-    if type(value) == 'string' then
-      return value
-    end
-    if not info.allows_duplicates then
-      value = remove_duplicate_values(value)
-    end
-    return table.concat(value, ',')
-  end,
-
-  map = function(_, value)
-    if type(value) == 'string' then
-      return value
-    end
-
-    local result = {}
-    for opt_key, opt_value in pairs(value) do
-      table.insert(result, string.format('%s:%s', opt_key, opt_value))
-    end
-
-    table.sort(result)
-    return table.concat(result, ',')
-  end,
-}
-
---- Convert a Lua value to a vimoption_T value
-local function convert_value_to_vim(name, info, value)
-  if value == nil then
-    return vim.NIL
-  end
-
-  assert_valid_value(name, value, valid_types[info.metatype])
-
-  return to_vim_value[info.metatype](info, value)
-end
-
--- Map of OptionType to functions that take vimoption_T values and convert to Lua values.
--- Each function takes (info, vim_value) -> lua_value
-local to_lua_value = {
-  boolean = passthrough,
-  number = passthrough,
-  string = passthrough,
-
-  array = function(info, value)
-    if type(value) == 'table' then
-      if not info.allows_duplicates then
-        value = remove_duplicate_values(value)
-      end
-
-      return value
-    end
-
-    -- Empty strings mean that there is nothing there,
-    -- so empty table should be returned.
-    if value == '' then
-      return {}
-    end
-
-    -- Handles unescaped commas in a list.
-    if string.find(value, ',,,') then
-      local left, right = unpack(vim.split(value, ',,,'))
-
-      local result = {}
-      vim.list_extend(result, vim.split(left, ','))
-      table.insert(result, ',')
-      vim.list_extend(result, vim.split(right, ','))
-
-      table.sort(result)
-
-      return result
-    end
-
-    if string.find(value, ',^,,', 1, true) then
-      local left, right = unpack(vim.split(value, ',^,,', true))
-
-      local result = {}
-      vim.list_extend(result, vim.split(left, ','))
-      table.insert(result, '^,')
-      vim.list_extend(result, vim.split(right, ','))
-
-      table.sort(result)
-
-      return result
-    end
-
-    return vim.split(value, ',')
-  end,
-
-  set = function(info, value)
-    if type(value) == 'table' then
-      return value
-    end
-
-    -- Empty strings mean that there is nothing there,
-    -- so empty table should be returned.
-    if value == '' then
-      return {}
-    end
-
-    assert(info.flaglist, 'That is the only one I know how to handle')
-
-    if info.flaglist and info.commalist then
-      local split_value = vim.split(value, ',')
-      local result = {}
-      for _, v in ipairs(split_value) do
-        result[v] = true
-      end
-
-      return result
-    else
-      local result = {}
-      for i = 1, #value do
-        result[value:sub(i, i)] = true
-      end
-
-      return result
-    end
-  end,
-
-  map = function(info, raw_value)
-    if type(raw_value) == 'table' then
-      return raw_value
-    end
-
-    assert(info.commalist, 'Only commas are supported currently')
-
-    local result = {}
-
-    local comma_split = vim.split(raw_value, ',')
-    for _, key_value_str in ipairs(comma_split) do
-      local key, value = unpack(vim.split(key_value_str, ':'))
-      key = vim.trim(key)
-
-      result[key] = value
-    end
-
-    return result
-  end,
-}
-
---- Converts a vimoption_T style value to a Lua value
-local function convert_value_to_lua(info, option_value)
-  return to_lua_value[info.metatype](info, option_value)
-end
-
-local prepend_methods = {
-  number = function()
-    error("The '^' operator is not currently supported for")
-  end,
-
-  string = function(left, right)
-    return right .. left
-  end,
-
-  array = function(left, right)
-    for i = #right, 1, -1 do
-      table.insert(left, 1, right[i])
-    end
-
-    return left
-  end,
-
-  map = tbl_merge,
-  set = tbl_merge,
-}
-
---- Handles the '^' operator
-local function prepend_value(info, current, new)
-  return prepend_methods[info.metatype](
-    convert_value_to_lua(info, current),
-    convert_value_to_lua(info, new)
-  )
-end
-
-local add_methods = {
-  number = function(left, right)
-    return left + right
-  end,
-
-  string = function(left, right)
-    return left .. right
-  end,
-
-  array = function(left, right)
-    for _, v in ipairs(right) do
-      table.insert(left, v)
-    end
-
-    return left
-  end,
-
-  map = tbl_merge,
-  set = tbl_merge,
-}
-
---- Handles the '+' operator
-local function add_value(info, current, new)
-  return add_methods[info.metatype](
-    convert_value_to_lua(info, current),
-    convert_value_to_lua(info, new)
-  )
-end
-
-local function remove_one_item(t, val)
-  if vim.tbl_islist(t) then
-    local remove_index = nil
-    for i, v in ipairs(t) do
-      if v == val then
-        remove_index = i
-      end
-    end
-
-    if remove_index then
-      table.remove(t, remove_index)
-    end
-  else
-    t[val] = nil
-  end
-end
-
-local remove_methods = {
-  number = function(left, right)
-    return left - right
-  end,
-
-  string = function()
-    error('Subtraction not supported for strings.')
-  end,
-
-  array = function(left, right)
-    if type(right) == 'string' then
-      remove_one_item(left, right)
-    else
-      for _, v in ipairs(right) do
-        remove_one_item(left, v)
-      end
-    end
-
-    return left
-  end,
-
-  map = tbl_remove,
-  set = tbl_remove,
-}
-
---- Handles the '-' operator
-local function remove_value(info, current, new)
-  return remove_methods[info.metatype](convert_value_to_lua(info, current), new)
-end
-
-local function create_option_accessor(scope)
-  local option_mt
-
-  local function make_option(name, value)
-    local info = assert(options_info[name], 'Not a valid option name: ' .. name)
-
-    if type(value) == 'table' and getmetatable(value) == option_mt then
-      assert(name == value._name, "must be the same value, otherwise that's weird.")
-
-      value = value._value
-    end
-
-    return setmetatable({
-      _name = name,
-      _value = value,
-      _info = info,
-    }, option_mt)
-  end
-
-  option_mt = {
-    -- To set a value, instead use:
-    --  opt[my_option] = value
-    _set = function(self)
-      local value = convert_value_to_vim(self._name, self._info, self._value)
-      api.nvim_set_option_value(self._name, value, { scope = scope })
-    end,
-
-    get = function(self)
-      return convert_value_to_lua(self._info, self._value)
-    end,
-
-    append = function(self, right)
-      self._value = add_value(self._info, self._value, right)
-      self:_set()
-    end,
-
-    __add = function(self, right)
-      return make_option(self._name, add_value(self._info, self._value, right))
-    end,
-
-    prepend = function(self, right)
-      self._value = prepend_value(self._info, self._value, right)
-      self:_set()
-    end,
-
-    __pow = function(self, right)
-      return make_option(self._name, prepend_value(self._info, self._value, right))
-    end,
-
-    remove = function(self, right)
-      self._value = remove_value(self._info, self._value, right)
-      self:_set()
-    end,
-
-    __sub = function(self, right)
-      return make_option(self._name, remove_value(self._info, self._value, right))
-    end,
-  }
-  option_mt.__index = option_mt
-
-  return setmetatable({}, {
-    __index = function(_, k)
-      return make_option(k, api.nvim_get_option_value(k, {}))
-    end,
-
-    __newindex = function(_, k, v)
-      make_option(k, v):_set()
-    end,
-  })
-end
-
-vim.opt = create_option_accessor()
-vim.opt_local = create_option_accessor('local')
-vim.opt_global = create_option_accessor('global')
diff --git a/runtime/lua/vim/_meta/builtin.lua b/runtime/lua/vim/_meta/builtin.lua
new file mode 100644
index 0000000000..980e40d61b
--- /dev/null
+++ b/runtime/lua/vim/_meta/builtin.lua
@@ -0,0 +1,238 @@
+---@meta
+
+-- luacheck: no unused args
+
+---@defgroup vim.builtin
+---
+---@brief <pre>help
+---vim.api.{func}({...})                                                    *vim.api*
+---    Invokes Nvim |API| function {func} with arguments {...}.
+---    Example: call the "nvim_get_current_line()" API function: >lua
+---        print(tostring(vim.api.nvim_get_current_line()))
+---
+---vim.NIL                                                                  *vim.NIL*
+---    Special value representing NIL in |RPC| and |v:null| in Vimscript
+---    conversion, and similar cases. Lua `nil` cannot be used as part of a Lua
+---    table representing a Dictionary or Array, because it is treated as
+---    missing: `{"foo", nil}` is the same as `{"foo"}`.
+---
+---vim.type_idx                                                        *vim.type_idx*
+---    Type index for use in |lua-special-tbl|. Specifying one of the values from
+---    |vim.types| allows typing the empty table (it is unclear whether empty Lua
+---    table represents empty list or empty array) and forcing integral numbers
+---    to be |Float|. See |lua-special-tbl| for more details.
+---
+---vim.val_idx                                                          *vim.val_idx*
+---    Value index for tables representing |Float|s. A table representing
+---    floating-point value 1.0 looks like this: >lua
+---        {
+---          [vim.type_idx] = vim.types.float,
+---          [vim.val_idx] = 1.0,
+---        }
+---<    See also |vim.type_idx| and |lua-special-tbl|.
+---
+---vim.types                                                              *vim.types*
+---    Table with possible values for |vim.type_idx|. Contains two sets of
+---    key-value pairs: first maps possible values for |vim.type_idx| to
+---    human-readable strings, second maps human-readable type names to values
+---    for |vim.type_idx|. Currently contains pairs for `float`, `array` and
+---        `dictionary` types.
+---
+---    Note: One must expect that values corresponding to `vim.types.float`,
+---    `vim.types.array` and `vim.types.dictionary` fall under only two following
+---    assumptions:
+---    1. Value may serve both as a key and as a value in a table. Given the
+---       properties of Lua tables this basically means “value is not `nil`”.
+---    2. For each value in `vim.types` table `vim.types[vim.types[value]]` is the
+---       same as `value`.
+---    No other restrictions are put on types, and it is not guaranteed that
+---    values corresponding to `vim.types.float`, `vim.types.array` and
+---    `vim.types.dictionary` will not change or that `vim.types` table will only
+---    contain values for these three types.
+---
+---                                                   *log_levels* *vim.log.levels*
+---Log levels are one of the values defined in `vim.log.levels`:
+---
+---    vim.log.levels.DEBUG
+---    vim.log.levels.ERROR
+---    vim.log.levels.INFO
+---    vim.log.levels.TRACE
+---    vim.log.levels.WARN
+---    vim.log.levels.OFF
+---
+---</pre>
+
+--- Returns true if the code is executing as part of a "fast" event handler,
+--- where most of the API is disabled. These are low-level events (e.g.
+--- |lua-loop-callbacks|) which can be invoked whenever Nvim polls for input.
+--- When this is `false` most API functions are callable (but may be subject
+--- to other restrictions such as |textlock|).
+function vim.in_fast_event() end
+
+--- Creates a special empty table (marked with a metatable), which Nvim to an
+--- empty dictionary when translating Lua values to Vimscript or API types.
+--- Nvim by default converts an empty table `{}` without this metatable to an
+--- list/array.
+---
+--- Note: If numeric keys are present in the table, Nvim ignores the metatable
+--- marker and converts the dict to a list/array anyway.
+function vim.empty_dict() end
+
+--- Sends {event} to {channel} via |RPC| and returns immediately. If {channel}
+--- is 0, the event is broadcast to all channels.
+---
+--- This function also works in a fast callback |lua-loop-callbacks|.
+--- @param channel integer
+--- @param method string
+--- @param args? any[]
+--- @param ...? any
+function vim.rpcnotify(channel, method, args, ...) end
+
+--- Sends a request to {channel} to invoke {method} via |RPC| and blocks until
+--- a response is received.
+---
+--- Note: NIL values as part of the return value is represented as |vim.NIL|
+--- special value
+--- @param channel integer
+--- @param method string
+--- @param args? any[]
+--- @param ...? any
+function vim.rpcrequest(channel, method, args, ...) end
+
+--- Compares strings case-insensitively.
+--- @param a string
+--- @param b string
+--- @return 0|1|-1
+--- if strings are
+--- equal, {a} is greater than {b} or {a} is lesser than {b}, respectively.
+function vim.stricmp(a, b) end
+
+--- Convert UTF-32 or UTF-16 {index} to byte index. If {use_utf16} is not
+--- supplied, it defaults to false (use UTF-32). Returns the byte index.
+---
+--- Invalid UTF-8 and NUL is treated like by |vim.str_byteindex()|.
+--- An {index} in the middle of a UTF-16 sequence is rounded upwards to
+--- the end of that sequence.
+--- @param str string
+--- @param index number
+--- @param use_utf16? any
+function vim.str_byteindex(str, index, use_utf16) end
+
+--- Convert byte index to UTF-32 and UTF-16 indices. If {index} is not
+--- supplied, the length of the string is used. All indices are zero-based.
+---
+--- Embedded NUL bytes are treated as terminating the string. Invalid UTF-8
+--- bytes, and embedded surrogates are counted as one code point each. An
+--- {index} in the middle of a UTF-8 sequence is rounded upwards to the end of
+--- that sequence.
+--- @param str string
+--- @param index? number
+--- @return integer UTF-32 index
+--- @return integer UTF-16 index
+function vim.str_utfindex(str, index) end
+
+--- The result is a String, which is the text {str} converted from
+--- encoding {from} to encoding {to}. When the conversion fails `nil` is
+--- returned.  When some characters could not be converted they
+--- are replaced with "?".
+--- The encoding names are whatever the iconv() library function
+--- can accept, see ":Man 3 iconv".
+---
+--- @param str string Text to convert
+--- @param from number Encoding of {str}
+--- @param to number Target encoding
+--- @param opts? table<string,any>
+--- @return string|nil Converted string if conversion succeeds, `nil` otherwise.
+function vim.iconv(str, from, to, opts) end
+
+--- Schedules {callback} to be invoked soon by the main event-loop. Useful
+--- to avoid |textlock| or other temporary restrictions.
+--- @param callback fun()
+function vim.schedule(callback) end
+
+--- Wait for {time} in milliseconds until {callback} returns `true`.
+---
+--- Executes {callback} immediately and at approximately {interval}
+--- milliseconds (default 200). Nvim still processes other events during
+--- this time.
+---
+--- Examples:
+--- <pre>lua
+---
+--- ---
+--- -- Wait for 100 ms, allowing other events to process
+--- vim.wait(100, function() end)
+---
+--- ---
+--- -- Wait for 100 ms or until global variable set.
+--- vim.wait(100, function() return vim.g.waiting_for_var end)
+---
+--- ---
+--- -- Wait for 1 second or until global variable set, checking every ~500 ms
+--- vim.wait(1000, function() return vim.g.waiting_for_var end, 500)
+---
+--- ---
+--- -- Schedule a function to set a value in 100ms
+--- vim.defer_fn(function() vim.g.timer_result = true end, 100)
+---
+--- -- Would wait ten seconds if results blocked. Actually only waits  100 ms
+--- if vim.wait(10000, function() return vim.g.timer_result end) then
+---   print('Only waiting a little bit of time!')
+--- end
+--- </pre>
+---
+--- @param time integer Number of milliseconds to wait
+--- @param callback? fun(): boolean Optional callback. Waits until {callback} returns true
+--- @param interval? integer (Approximate) number of milliseconds to wait between polls
+--- @param fast_only? boolean If true, only |api-fast| events will be processed.
+---                           If called from while in an |api-fast| event, will
+---                           automatically be set to `true`.
+--- @return boolean, nil|-1|-2
+---     - If {callback} returns `true` during the {time}: `true, nil`
+---     - If {callback} never returns `true` during the {time}: `false, -1`
+---     - If {callback} is interrupted during the {time}: `false, -2`
+---     - If {callback} errors, the error is raised.
+function vim.wait(time, callback, interval, fast_only) end
+
+--- Attach to ui events, similar to |nvim_ui_attach()| but receive events
+--- as Lua callback. Can be used to implement screen elements like
+--- popupmenu or message handling in Lua.
+---
+--- {options} should be a dictionary-like table, where `ext_...` options should
+--- be set to true to receive events for the respective external element.
+---
+--- {callback} receives event name plus additional parameters. See |ui-popupmenu|
+--- and the sections below for event format for respective events.
+---
+--- WARNING: This api is considered experimental.  Usability will vary for
+--- different screen elements. In particular `ext_messages` behavior is subject
+--- to further changes and usability improvements.  This is expected to be
+--- used to handle messages when setting 'cmdheight' to zero (which is
+--- likewise experimental).
+---
+--- Example (stub for a |ui-popupmenu| implementation):
+--- <pre>lua
+---
+---   ns = vim.api.nvim_create_namespace('my_fancy_pum')
+---
+---   vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
+---     if event == "popupmenu_show" then
+---       local items, selected, row, col, grid = ...
+---       print("display pum ", #items)
+---     elseif event == "popupmenu_select" then
+---       local selected = ...
+---       print("selected", selected)
+---     elseif event == "popupmenu_hide" then
+---       print("FIN")
+---     end
+---   end)
+--- </pre>
+--- @param ns integer
+--- @param options table<string, any>
+--- @param callback fun()
+function vim.ui_attach(ns, options, callback) end
+
+--- Detach a callback previously attached with |vim.ui_attach()| for the
+--- given namespace {ns}.
+--- @param ns integer
+function vim.ui_detach(ns) end
diff --git a/runtime/lua/vim/_meta/diff.lua b/runtime/lua/vim/_meta/diff.lua
new file mode 100644
index 0000000000..246ac0c75a
--- /dev/null
+++ b/runtime/lua/vim/_meta/diff.lua
@@ -0,0 +1,69 @@
+---@meta
+
+-- luacheck: no unused args
+
+--- Run diff on strings {a} and {b}. Any indices returned by this function,
+--- either directly or via callback arguments, are 1-based.
+---
+--- Examples:
+--- <pre>lua
+---     vim.diff('a\\n', 'b\\nc\\n')
+---     -- =>
+---     -- @@ -1 +1,2 @@
+---     -- -a
+---     -- +b
+---     -- +c
+---
+---     vim.diff('a\\n', 'b\\nc\\n', {result_type = 'indices'})
+---     -- =>
+---     -- {
+---     --   {1, 1, 1, 2}
+---     -- }
+--- </pre>
+---
+--- @param a string First string to compare
+--- @param b string Second string to compare
+--- @param opts table<string,any> Optional parameters:
+---     - `on_hunk` (callback):
+---       Invoked for each hunk in the diff. Return a negative number
+---       to cancel the callback for any remaining hunks.
+---       Args:
+---       - `start_a` (integer): Start line of hunk in {a}.
+---       - `count_a` (integer): Hunk size in {a}.
+---       - `start_b` (integer): Start line of hunk in {b}.
+---       - `count_b` (integer): Hunk size in {b}.
+---     - `result_type` (string): Form of the returned diff:
+---       - "unified": (default) String in unified format.
+---       - "indices": Array of hunk locations.
+---       Note: This option is ignored if `on_hunk` is used.
+---     - `linematch` (boolean|integer): Run linematch on the resulting hunks
+---       from xdiff. When integer, only hunks upto this size in
+---       lines are run through linematch. Requires `result_type = indices`,
+---       ignored otherwise.
+---     - `algorithm` (string):
+---       Diff algorithm to use. Values:
+---       - "myers"      the default algorithm
+---       - "minimal"    spend extra time to generate the
+---                      smallest possible diff
+---       - "patience"   patience diff algorithm
+---       - "histogram"  histogram diff algorithm
+---     - `ctxlen` (integer): Context length
+---     - `interhunkctxlen` (integer):
+---       Inter hunk context length
+---     - `ignore_whitespace` (boolean):
+---       Ignore whitespace
+---     - `ignore_whitespace_change` (boolean):
+---       Ignore whitespace change
+---     - `ignore_whitespace_change_at_eol` (boolean)
+---       Ignore whitespace change at end-of-line.
+---     - `ignore_cr_at_eol` (boolean)
+---       Ignore carriage return at end-of-line
+---     - `ignore_blank_lines` (boolean)
+---       Ignore blank lines
+---     - `indent_heuristic` (boolean):
+---       Use the indent heuristic for the internal
+---       diff library.
+---
+--- @return string|table|nil
+---     See {opts.result_type}. `nil` if {opts.on_hunk} is given.
+function vim.diff(a, b, opts) end
diff --git a/runtime/lua/vim/_meta/json.lua b/runtime/lua/vim/_meta/json.lua
new file mode 100644
index 0000000000..76a6c7b733
--- /dev/null
+++ b/runtime/lua/vim/_meta/json.lua
@@ -0,0 +1,37 @@
+--- @meta
+
+-- luacheck: no unused args
+
+--- @defgroup vim.json
+---
+--- This module provides encoding and decoding of Lua objects to and
+--- from JSON-encoded strings. Supports |vim.NIL| and |vim.empty_dict()|.
+
+--- Decodes (or "unpacks") the JSON-encoded {str} to a Lua object.
+---
+--- - Decodes JSON "null" as |vim.NIL| (controllable by {opts}, see below).
+--- - Decodes empty object as |vim.empty_dict()|.
+--- - Decodes empty array as `{}` (empty Lua table).
+---
+--- Example:
+--- <pre>lua
+--- :lua vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
+--- --> { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
+--- </pre>
+--- Parameters: ~
+---   • {str}    Stringified JSON data.
+---   • {opts}   Options map keys:
+---              • luanil: { object: bool, array: bool }
+---                • `luanil.object=true` converts `null` in JSON objects to
+---                  Lua `nil` instead of `vim.NIL`.
+---                • `luanil.array=true` converts `null` in JSON arrays to Lua
+---                  `nil` instead of `vim.NIL`.
+--- @param str string
+--- @param opts? table<string, any>
+--- @return any
+function vim.json.decode(str, opts) end
+
+--- Encodes (or "packs") Lua object {obj} as JSON in a Lua string.
+--- @param obj any
+--- @return string
+function vim.json.encode(obj) end
diff --git a/runtime/lua/vim/_meta/misc.lua b/runtime/lua/vim/_meta/misc.lua
new file mode 100644
index 0000000000..8a76755962
--- /dev/null
+++ b/runtime/lua/vim/_meta/misc.lua
@@ -0,0 +1,13 @@
+---@meta
+
+-- luacheck: no unused args
+
+--- Invokes |vim-function| or |user-function| {func} with arguments {...}.